hexsha
stringlengths 40
40
| size
int64 7
1.05M
| ext
stringclasses 13
values | lang
stringclasses 1
value | max_stars_repo_path
stringlengths 4
269
| max_stars_repo_name
stringlengths 5
109
| max_stars_repo_head_hexsha
stringlengths 40
40
| max_stars_repo_licenses
listlengths 1
9
| max_stars_count
int64 1
191k
⌀ | max_stars_repo_stars_event_min_datetime
stringlengths 24
24
⌀ | max_stars_repo_stars_event_max_datetime
stringlengths 24
24
⌀ | max_issues_repo_path
stringlengths 4
269
| max_issues_repo_name
stringlengths 5
116
| max_issues_repo_head_hexsha
stringlengths 40
40
| max_issues_repo_licenses
listlengths 1
9
| max_issues_count
int64 1
48.5k
⌀ | max_issues_repo_issues_event_min_datetime
stringlengths 24
24
⌀ | max_issues_repo_issues_event_max_datetime
stringlengths 24
24
⌀ | max_forks_repo_path
stringlengths 4
269
| max_forks_repo_name
stringlengths 5
116
| max_forks_repo_head_hexsha
stringlengths 40
40
| max_forks_repo_licenses
listlengths 1
9
| max_forks_count
int64 1
105k
⌀ | max_forks_repo_forks_event_min_datetime
stringlengths 24
24
⌀ | max_forks_repo_forks_event_max_datetime
stringlengths 24
24
⌀ | content
stringlengths 7
1.05M
| avg_line_length
float64 1.21
330k
| max_line_length
int64 6
990k
| alphanum_fraction
float64 0.01
0.99
| author_id
stringlengths 2
40
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
6c2ed407d7aa95953c9a231d34a2db3a1124f03c
| 1,062
|
cpp
|
C++
|
Source/wali/lib/witness/WitnessTrans.cpp
|
jusito/WALi-OpenNWA
|
2bb4aca02c5a5d444fd038e8aa3eecd7d1ccbb99
|
[
"MIT"
] | 15
|
2015-03-07T17:25:57.000Z
|
2022-02-04T20:17:00.000Z
|
Source/wali/lib/witness/WitnessTrans.cpp
|
jusito/WALi-OpenNWA
|
2bb4aca02c5a5d444fd038e8aa3eecd7d1ccbb99
|
[
"MIT"
] | 1
|
2018-03-03T05:58:55.000Z
|
2018-03-03T12:26:10.000Z
|
Source/wali/lib/witness/WitnessTrans.cpp
|
jusito/WALi-OpenNWA
|
2bb4aca02c5a5d444fd038e8aa3eecd7d1ccbb99
|
[
"MIT"
] | 15
|
2015-09-25T17:44:35.000Z
|
2021-07-18T18:25:38.000Z
|
/*!
* @author Nicholas Kidd
*/
#include "wali/Common.hpp"
#include "wali/witness/WitnessTrans.hpp"
#include "wali/witness/Visitor.hpp"
namespace wali
{
namespace witness
{
WitnessTrans::WitnessTrans( const wfa::ITrans& t_ ) : Witness(t_.weight()),t(t_)
{
min_length = 0UL;
}
// Destructor does nothing.
WitnessTrans::~WitnessTrans()
{
}
//
// Override Witness::accept
//
void WitnessTrans::accept( Visitor& v, bool visitOnce ATTR_UNUSED )
{
// TODO how does marking work...need a flag maybe
(void) visitOnce;
mark();
if (v.visitTrans(this)) {
v.postvisitTrans(this);
}
}
// Overrides Witness::prettyPrint
std::ostream& WitnessTrans::prettyPrint( std::ostream& o,size_t depth ) const
{
formatDepth(o,depth);
o << "WitnessTrans: ";
t.print(o) << std::endl;
return o;
}
const wfa::Trans& WitnessTrans::getTrans() const
{
return t;
}
} // namespace witness
} // namespace wali
/*
* $Id$
*/
| 18.310345
| 84
| 0.585687
|
jusito
|
6c2f2499b2fd88095195371e9bcdf6882f99527d
| 7,784
|
cpp
|
C++
|
IslandGame/src/islandgame/IslandGame.cpp
|
haferflocken/ConductorEngine
|
4914e419e5a736275e96d76eaa19b7aa56d69345
|
[
"Zlib",
"BSD-2-Clause"
] | null | null | null |
IslandGame/src/islandgame/IslandGame.cpp
|
haferflocken/ConductorEngine
|
4914e419e5a736275e96d76eaa19b7aa56d69345
|
[
"Zlib",
"BSD-2-Clause"
] | null | null | null |
IslandGame/src/islandgame/IslandGame.cpp
|
haferflocken/ConductorEngine
|
4914e419e5a736275e96d76eaa19b7aa56d69345
|
[
"Zlib",
"BSD-2-Clause"
] | null | null | null |
#include <islandgame/IslandGameData.h>
#include <islandgame/client/IslandGameClient.h>
#include <islandgame/host/IslandGameHost.h>
#include <asset/AssetManager.h>
#include <collection/LocklessQueue.h>
#include <collection/ProgramParameters.h>
#include <file/Path.h>
#include <client/ClientWorld.h>
#include <client/ConnectedHost.h>
#include <client/IRenderInstance.h>
#include <client/MessageToHost.h>
#include <client/MessageToRenderInstance.h>
#include <conductor/ApplicationErrorCode.h>
#include <conductor/IGameData.h>
#include <conductor/LocalClientHostMain.h>
#include <conductor/HostMain.h>
#include <conductor/RemoteClientMain.h>
#include <condui/ConduiECSRegistration.h>
#include <host/ConnectedClient.h>
#include <host/HostNetworkWorld.h>
#include <host/HostWorld.h>
#include <host/MessageToClient.h>
#include <input/InputMessage.h>
#include <network/Socket.h>
#include <renderer/AssetTypes.h>
#include <renderer/RenderInstance.h>
#include <iostream>
namespace Internal_IslandGame
{
constexpr char* k_dataDirectoryParameter = "-datapath";
constexpr char* k_userGamePath = "Documents/My Games/IslandGame/";
constexpr char* k_applicationModeClientParameter = "-client";
constexpr char* k_applicationModeHostParameter = "-host";
enum class ApplicationMode
{
Invalid = 0,
Client,
Host,
};
int ClientMain(const Collection::ProgramParameters& params, const File::Path& dataDirectory,
const File::Path& userDirectory, Asset::AssetManager& assetManager, std::string& hostParam);
int HostMain(const Collection::ProgramParameters& params, const File::Path& dataDirectory,
const File::Path& userDirectory, Asset::AssetManager& assetManager, const std::string& port);
// Define the factory functions that abstract game code away from engine code.
Client::RenderInstanceFactory MakeRenderInstanceFactory()
{
return [](Asset::AssetManager& assetManager,
const File::Path& dataDirectory,
Collection::LocklessQueue<Client::MessageToRenderInstance>& clientToRenderInstanceMessages,
Collection::LocklessQueue<Input::InputMessage>& inputToClientMessages)
{
return Mem::MakeUnique<Renderer::RenderInstance>(assetManager,
clientToRenderInstanceMessages, inputToClientMessages, "IslandGame");
};
}
Conductor::GameDataFactory MakeGameDataFactory()
{
return [](Asset::AssetManager& assetManager, const File::Path& dataDirectory, const File::Path& userDirectory)
{
auto gameData = Mem::MakeUnique<IslandGame::IslandGameData>(dataDirectory, userDirectory, assetManager);
Condui::RegisterComponentTypes(gameData->GetComponentReflector());
Renderer::RenderInstance::RegisterComponentTypes(gameData->GetComponentReflector());
return gameData;
};
}
Mem::UniquePtr<Client::IClient> MakeClient(const Conductor::IGameData& gameData, const Math::Frustum& sceneViewFrustum,
Client::ConnectedHost& connectedHost)
{
auto client = Mem::MakeUnique<IslandGame::Client::IslandGameClient>(
static_cast<const IslandGame::IslandGameData&>(gameData),
connectedHost);
Condui::RegisterSystems(client->GetEntityManager(), sceneViewFrustum, client->GetInputCallbackRegistry());
return client;
}
Host::HostWorld::HostFactory MakeHostFactory()
{
return [](const Conductor::IGameData& gameData)
{
return Mem::MakeUnique<IslandGame::Host::IslandGameHost>(
static_cast<const IslandGame::IslandGameData&>(gameData));
};
}
}
int main(const int argc, const char* argv[])
{
using namespace Internal_IslandGame;
// Extract the data directory from the command line parameters.
const Collection::ProgramParameters params{ argc, argv };
std::string dataDirectoryStr;
if (!params.TryGet(k_dataDirectoryParameter, dataDirectoryStr))
{
std::cerr << "Missing required parameter: -datapath <dir>" << std::endl;
return static_cast<int>(Conductor::ApplicationErrorCode::MissingDataPath);
}
const File::Path dataDirectory = File::MakePath(dataDirectoryStr.c_str());
// Get the user directory.
char userDirBuffer[128];
size_t userDirLength;
const errno_t userDirErrorCode = getenv_s(&userDirLength, userDirBuffer, "USERPROFILE");
if (userDirErrorCode != 0 || userDirLength == 0)
{
std::cerr << "Failed to get the user path from the system." << std::endl;
return static_cast<int>(Conductor::ApplicationErrorCode::FailedToGetUserPath);
}
const File::Path userDirectory = File::MakePath(userDirBuffer) / k_userGamePath;
// Determine the application mode from the command line parameters.
ApplicationMode applicationMode = ApplicationMode::Invalid;
std::string applicationModeParamater;
if (params.TryGet(k_applicationModeClientParameter, applicationModeParamater))
{
applicationMode = ApplicationMode::Client;
}
else if (params.TryGet(k_applicationModeHostParameter, applicationModeParamater))
{
applicationMode = ApplicationMode::Host;
}
else
{
std::cerr << "Missing application mode parameter: -client hostName or -host hostPort" << std::endl;
return static_cast<int>(Conductor::ApplicationErrorCode::MissingApplicationMode);
}
// Create an asset manager and register the asset types it needs.
Asset::AssetManager assetManager{ dataDirectory };
Renderer::RegisterAssetTypes(assetManager);
// Run the application in the specified mode.
const int result = (applicationMode == ApplicationMode::Client)
? ClientMain(params, dataDirectory, userDirectory, assetManager, applicationModeParamater)
: HostMain(params, dataDirectory, userDirectory, assetManager, applicationModeParamater);
// Unregister the asset types from the asset manager in the opposite order they were registered.
Renderer::UnregisterAssetTypes(assetManager);
return result;
}
int Internal_IslandGame::ClientMain(
const Collection::ProgramParameters& params,
const File::Path& dataDirectory,
const File::Path& userDirectory,
Asset::AssetManager& assetManager,
std::string& hostParam)
{
// Ensure a host parameter was specified.
if (hostParam.size() < 3)
{
return static_cast<int>(Conductor::ApplicationErrorCode::MissingClientHostName);
}
// If the host is specified as "newhost", spin up a local host with no network thread: just direct communication.
// Otherwise, connect to a remote host.
if (strcmp(hostParam.c_str(), "newhost") == 0)
{
const Conductor::ApplicationErrorCode errorCode = Conductor::LocalClientHostMain(params, dataDirectory, userDirectory,
assetManager, MakeRenderInstanceFactory(), MakeGameDataFactory(), &MakeClient, MakeHostFactory());
return static_cast<int>(errorCode);
}
else
{
// Extract the host name and port from hostParam.
const size_t portStartIndex = hostParam.find_last_of(':');
if (portStartIndex == std::string::npos)
{
return static_cast<int>(Conductor::ApplicationErrorCode::MissingClientHostPort);
}
hostParam[portStartIndex] = '\0';
const char* const hostName = hostParam.c_str();
const char* const hostPort = hostName + portStartIndex + 1;
const Conductor::ApplicationErrorCode errorCode = Conductor::RemoteClientMain(params, dataDirectory, userDirectory,
assetManager, hostName, hostPort, MakeRenderInstanceFactory(), MakeGameDataFactory(), &MakeClient);
return static_cast<int>(errorCode);
}
return static_cast<int>(Conductor::ApplicationErrorCode::NoError);
}
int Internal_IslandGame::HostMain(
const Collection::ProgramParameters& params,
const File::Path& dataDirectory,
const File::Path& userDirectory,
Asset::AssetManager& assetManager,
const std::string& port)
{
// Ensure a port was specified.
if (port.empty())
{
return static_cast<int>(Conductor::ApplicationErrorCode::MissingHostPort);
}
// Run the host.
const Conductor::ApplicationErrorCode errorCode = Conductor::HostMain(params, dataDirectory, userDirectory,
assetManager, port.c_str(), MakeGameDataFactory(), MakeHostFactory());
return static_cast<int>(errorCode);
}
| 34.90583
| 120
| 0.778905
|
haferflocken
|
6c3158db09db4f1b13e698d4319e52778fd0ff18
| 168
|
cpp
|
C++
|
pointer/pointer.cpp
|
riti2409/forplacements
|
9e8fb99c9d65b04eea71abb3fbdcffc2a1433a04
|
[
"MIT"
] | 5
|
2021-12-03T14:29:16.000Z
|
2022-02-04T09:06:37.000Z
|
pointer/pointer.cpp
|
riti2409/forplacements
|
9e8fb99c9d65b04eea71abb3fbdcffc2a1433a04
|
[
"MIT"
] | null | null | null |
pointer/pointer.cpp
|
riti2409/forplacements
|
9e8fb99c9d65b04eea71abb3fbdcffc2a1433a04
|
[
"MIT"
] | 2
|
2022-01-16T14:20:42.000Z
|
2022-01-17T06:49:01.000Z
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int a=10;
int*aptr=&a;
cout<<*aptr<<endl;
*aptr=20;
cout<<a<<endl;
return 0;
}
| 16.8
| 24
| 0.52381
|
riti2409
|
6c3737314783146e7753ae1448cb9a717c131d45
| 777
|
cpp
|
C++
|
y2018/filters/houghCircles.cpp
|
valkyrierobotics/vision2018
|
aa82e936c5481b7cc43a46ff5f6e68702c2166c2
|
[
"BSD-2-Clause"
] | 2
|
2016-08-06T06:21:02.000Z
|
2017-01-10T05:45:13.000Z
|
y2018/filters/houghCircles.cpp
|
valkyrierobotics/vision2018
|
aa82e936c5481b7cc43a46ff5f6e68702c2166c2
|
[
"BSD-2-Clause"
] | 1
|
2017-04-15T20:54:59.000Z
|
2017-04-15T20:54:59.000Z
|
y2018/filters/houghCircles.cpp
|
valkyrierobotics/vision2018
|
aa82e936c5481b7cc43a46ff5f6e68702c2166c2
|
[
"BSD-2-Clause"
] | 3
|
2016-07-30T06:19:55.000Z
|
2017-02-07T01:55:05.000Z
|
#include "filters/houghCircles.hpp"
void houghCircles(cv::Mat& img, int minDist, int minRadius, int maxRadius)
{
std::vector<cv::Vec3f> circles;
cv::cvtColor(img, img, CV_BGR2GRAY);
// cv::HoughCircles calls cv::Canny internally
cv::HoughCircles(img, circles, CV_HOUGH_GRADIENT, 2, minDist, maxRadius, minRadius);
for (size_t i = 0; i < circles.size(); i++)
{
// Each circle is encoded in a 3 element vector (x, y, radius)
cv::Point center(cvRound(circles[i][0]), cvRound(circles[i][1]));
int radius = cvRound(circles[i][2]);
// Draw center of circle
cv::circle(img, center, 3, cv::Scalar(0,255,0), -1, 8, 0 );
// Draw circle
cv::circle(img, center, radius, cv::Scalar(0,0,255), 3, 8, 0 );
}
}
| 35.318182
| 86
| 0.616474
|
valkyrierobotics
|
6c3ef40794a4151be768318ac2f28bfc81321042
| 1,259
|
cpp
|
C++
|
src/platform/vulkan/descriptor_set_layout.cpp
|
PedroSFreire/LiftPR.Version
|
61e8e135335e3c4def80f345548620db95f1662d
|
[
"BSD-3-Clause"
] | 30
|
2019-07-24T09:58:22.000Z
|
2021-09-03T08:20:22.000Z
|
src/platform/vulkan/descriptor_set_layout.cpp
|
PedroSFreire/LiftPR.Version
|
61e8e135335e3c4def80f345548620db95f1662d
|
[
"BSD-3-Clause"
] | 15
|
2020-06-20T13:20:50.000Z
|
2021-04-26T16:05:33.000Z
|
src/platform/vulkan/descriptor_set_layout.cpp
|
PedroSFreire/LiftPR.Version
|
61e8e135335e3c4def80f345548620db95f1662d
|
[
"BSD-3-Clause"
] | 5
|
2020-06-17T08:38:34.000Z
|
2021-09-08T22:14:02.000Z
|
#include "descriptor_set_layout.h"
#include "device.h"
namespace vulkan {
DescriptorSetLayout::DescriptorSetLayout(const Device& device,
const std::vector<DescriptorBinding>& descriptor_bindings) :
device_(device) {
std::vector<VkDescriptorSetLayoutBinding> layout_bindings;
for (const auto& binding : descriptor_bindings) {
VkDescriptorSetLayoutBinding b = {};
b.binding = binding.Binding;
b.descriptorCount = binding.DescriptorCount;
b.descriptorType = binding.Type;
b.stageFlags = binding.Stage;
layout_bindings.push_back(b);
}
VkDescriptorSetLayoutCreateInfo layout_info = {};
layout_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
layout_info.bindingCount = static_cast<uint32_t>(layout_bindings.size());
layout_info.pBindings = layout_bindings.data();
vulkanCheck(vkCreateDescriptorSetLayout(device.handle(), &layout_info, nullptr, &layout_),
"create descriptor set layout");
}
DescriptorSetLayout::~DescriptorSetLayout() {
if (layout_ != nullptr) {
vkDestroyDescriptorSetLayout(device_.handle(), layout_, nullptr);
layout_ = nullptr;
}
}
} // namespace vulkan
| 33.131579
| 101
| 0.69579
|
PedroSFreire
|
6c45a4713441b34549eb3b35a4cca840641e279f
| 1,700
|
cpp
|
C++
|
Source/StealthyAssessment/EnemyPatrolAIController.cpp
|
Zero-One101/StealthyAssessment
|
db79768bc13cfdf0cf282ca391366b087595ef61
|
[
"MIT"
] | null | null | null |
Source/StealthyAssessment/EnemyPatrolAIController.cpp
|
Zero-One101/StealthyAssessment
|
db79768bc13cfdf0cf282ca391366b087595ef61
|
[
"MIT"
] | null | null | null |
Source/StealthyAssessment/EnemyPatrolAIController.cpp
|
Zero-One101/StealthyAssessment
|
db79768bc13cfdf0cf282ca391366b087595ef61
|
[
"MIT"
] | null | null | null |
// Fill out your copyright notice in the Description page of Project Settings.
#include "StealthyAssessment.h"
#include "EnemyPatrol.h"
#include "Runtime/Engine/Classes/Components/SkeletalMeshComponent.h"
#include "EnemyPatrolAIController.h"
AEnemyPatrolAIController::AEnemyPatrolAIController(const class FObjectInitializer& ObjectInitializer) : Super(ObjectInitializer)
{
}
void AEnemyPatrolAIController::BeginPlay()
{
// Set the player variable equal to the first player
Player = (AStealthyAssessmentCharacter*) GetWorld()->GetFirstPlayerController();
if (Player)
{
// Set the player as the current target
SetFocus(Player);
// Make the owning actor move towards the player
MoveToActor(Player);
}
Super::BeginPlay();
}
void AEnemyPatrolAIController::Tick(float DeltaSeconds)
{
// Rotate the owning actor to face the player
UpdateControlRotation(DeltaSeconds);
}
void AEnemyPatrolAIController::OnMoveCompleted(FAIRequestID RequestID, EPathFollowingResult::Type Result)
{
// Get the owning actor and cast it to an AEnemyPatrol pointer
AEnemyPatrol* owner = (AEnemyPatrol*)GetPawn();
TArray<USkeletalMeshComponent*> Components;
if (owner)
{
// Get all USkeletalMeshComponents from the owning actor and store them in the TArray
owner->GetComponents<USkeletalMeshComponent>(Components);
if (Components.Num() > 0)
{
// AEnemyPatrol only has one USkeletalMeshComponent, so we can just cast the first element in the array
USkeletalMeshComponent* bodyMeshComponent = Components[0];
if (bodyMeshComponent)
{
// Make AI ragdoll on collision
bodyMeshComponent->SetSimulatePhysics(true);
bodyMeshComponent->WakeAllRigidBodies();
}
}
}
}
| 27.868852
| 128
| 0.768235
|
Zero-One101
|
6c49f80670b81396fae894b8de0907946e9209a6
| 3,267
|
cpp
|
C++
|
Mendel's First Law.cpp
|
RonitPrasad1/Project_Rosalind-
|
59c59f6820b858f0dc08d62b2629a608d477ddb2
|
[
"MIT"
] | 1
|
2022-03-22T22:33:14.000Z
|
2022-03-22T22:33:14.000Z
|
Mendel's First Law.cpp
|
RonitPrasad1/Project_Rosalind-
|
59c59f6820b858f0dc08d62b2629a608d477ddb2
|
[
"MIT"
] | null | null | null |
Mendel's First Law.cpp
|
RonitPrasad1/Project_Rosalind-
|
59c59f6820b858f0dc08d62b2629a608d477ddb2
|
[
"MIT"
] | null | null | null |
//Mendel's First Law: Not checked
#include <iostream>
#include <string>
auto main(int argc, const char* argv[]) -> decltype ( 0 )
{
std::cout << "Sample Dataset: " << '\n';
std::string RNA;
std::cin >> RNA;
int RNALength = RNA.size();
for (int64_t i = 0; i < RNALength; ++i)
{
if (RNA[i] == 'UUU' && RNA[i] == 'UUC')
{
RNA[i] = 'F';
}
else if (RNA[i] == 'UUA' && RNA[i] == 'UUG')
{
RNA[i] = 'L';
}
else if (RNA[i] == 'UCU' && RNA[i] == 'UCC' && RNA[i] == 'UCA' && RNA[i] == 'UCG' )
{
RNA[i] = 'S';
}
else if (RNA[i] == 'UAU' && RNA[i] == 'UAC')
{
RNA[i] = 'Y';
}
else if (RNA[i] == 'UAA' && RNA[i] == 'UAG' && RNA[i] == 'UGA')
{
RNA[i] = 'Stop';
}
else if (RNA[i] == 'UGU' && RNA[i] == 'UGC')
{
RNA[i] = 'C';
}
else if (RNA[i] == 'UGG')
{
RNA[i] = 'W';
}
else if (RNA[i] == 'CUU' && RNA[i] == 'CUC' && RNA[i] == 'CUA' && RNA[i] == 'CUG')
{
RNA[i] = 'L';
}
else if (RNA[i] == 'CCU' && RNA[i] == 'CCC' && RNA[i] == 'CCA' && RNA[i] == 'CCG')
{
RNA[i] = 'P';
}
else if (RNA[i] == 'CAU' && RNA[i] == 'CAC')
{
RNA[i] = 'H';
}
else if (RNA[i] == 'CAA' && RNA[i] == 'CAG')
{
RNA[i] = 'Q';
}
else if (RNA[i] == 'CGU' && RNA[i] == 'CGC' && RNA[i] == 'CGA' && RNA[i] == 'CGG')
{
RNA[i] = 'R';
}
else if (RNA[i] == 'AUU' && RNA[i] == 'AUC' && RNA[i] == 'AUA')
{
RNA[i] = 'I';
}
else if (RNA[i] == 'AUG')
{
RNA[i] = 'M';
}
else if (RNA[i] == 'ACU' && RNA[i] == 'ACC' && RNA[i] == 'ACA' && RNA[i] == 'ACG')
{
RNA[i] = 'T';
}
else if (RNA[i] == 'AAU' && RNA[i] == 'AAC')
{
RNA[i] = 'N';
}
else if (RNA[i] == 'AAA' && RNA[i] == 'AAG')
{
RNA[i] = 'K';
}
else if (RNA[i] == 'AGU' && RNA[i] == 'AGC')
{
RNA[i] = 'S';
}
else if (RNA[i] == 'AGA' && RNA[i] == 'AGG')
{
RNA[i] = 'R';
}
else if (RNA[i] == 'GUU' && RNA[i] == 'GUC' && RNA[i] == 'GUA' && RNA[i] == 'GUG')
{
RNA[i] = 'V';
}
else if (RNA[i] == 'GCU' && RNA[i] == 'GCC' && RNA[i] == 'GCA' && RNA[i] == 'GCG')
{
RNA[i] = 'A';
}
else if (RNA[i] == 'GAU' && RNA[i] == 'GAC')
{
RNA[i] = 'D';
}
else if (RNA[i] == 'GAA' && RNA[i] == 'GAG')
{
RNA[i] = 'E';
}
else if (RNA[i] == 'GGU' && RNA[i] == 'GGC' && RNA[i] == 'GGA' && RNA[i] == 'GGG')
{
RNA[i] = 'G';
}
}
std::cout << "Sample Output: " << '\n';
for (int64_t i = 0; i < RNALength; ++i)
{
std::cout << RNA[i];
}
return 0;
}
| 27.453782
| 92
| 0.289562
|
RonitPrasad1
|
6c4d78ad738a07be087994f21a2be1c65d249b07
| 19,653
|
hpp
|
C++
|
libs/core/src/main/cpp/neurodidactic/core/arrays/detail/MdArrayCommon.hpp
|
tomault/neurodidactic
|
c2641d65ebe191667f945817227319f48388c55b
|
[
"Apache-2.0"
] | null | null | null |
libs/core/src/main/cpp/neurodidactic/core/arrays/detail/MdArrayCommon.hpp
|
tomault/neurodidactic
|
c2641d65ebe191667f945817227319f48388c55b
|
[
"Apache-2.0"
] | null | null | null |
libs/core/src/main/cpp/neurodidactic/core/arrays/detail/MdArrayCommon.hpp
|
tomault/neurodidactic
|
c2641d65ebe191667f945817227319f48388c55b
|
[
"Apache-2.0"
] | null | null | null |
#ifndef __NEURODIDACTIC__CORE__ARRAYS__DETAIL__MDARRAYCOMMON_HPP__
#define __NEURODIDACTIC__CORE__ARRAYS__DETAIL__MDARRAYCOMMON_HPP__
#include <neurodidactic/core/arrays/DimensionList.hpp>
#include <neurodidactic/core/arrays/AnyMdArray.hpp>
#include <neurodidactic/core/arrays/detail/MklAdapter.hpp>
#include <pistis/exceptions/ExceptionOrigin.hpp>
#include <pistis/exceptions/IllegalValueError.hpp>
namespace neurodidactic {
namespace core {
namespace arrays {
namespace detail {
template <typename DerivedArray,
typename NewArray,
typename ArraySlice,
typename InnerProductResult,
size_t ARRAY_ORDER,
typename Field, typename Allocator>
class MdArrayCommon : public AnyMdArray<DerivedArray> {
protected:
typedef typename std::allocator_traits<Allocator>
::template rebind_alloc<uint32_t>
DimensionListAllocator;
public:
static constexpr const size_t ORDER = ARRAY_ORDER;
typedef Field FieldType;
typedef Allocator AllocatorType;
typedef DimensionList<DimensionListAllocator> DimensionListType;
typedef ArraySlice SliceType;
typedef MdArrayCommon<DerivedArray, NewArray, ArraySlice,
InnerProductResult, ARRAY_ORDER, Field,
Allocator>
ThisType;
public:
const AllocatorType& allocator() const {
return this->self().allocator_();
}
AllocatorType& allocator() { return this->self().allocator_(); }
size_t size() const { return this->self().size_(); }
size_t leadingDimension() const {
return this->self().leadingDimension_();
}
const DimensionListType& dimensions() const {
return this->self().dimensions_();
}
const Field* data() const { return this->self().data_(); }
Field* data() { return this->self().data_(); }
const Field* begin() const { return this->self().data_(); }
Field* begin() { return this->self().data_(); }
const Field* end() const { return this->self().end_(); }
Field* end() { return this->self().end_(); }
template <typename OtherArray,
typename Enabled =
typename std::enable_if<
IsMdArray<OtherArray>::value, NewArray
>::type
>
Enabled add(const OtherArray& other) const {
validateDimensions_("Array \"other\"", other.dimensions(),
PISTIS_EX_HERE);
NewArray result(this->dimensions(), this->allocator());
return std::move(this->add(other, result));
}
template <typename OtherArray,
typename ResultArray,
typename Enabled =
typename std::enable_if<
IsMdArray<OtherArray>::value &&
IsMdArray<ResultArray>::value,
int
>::type
>
ResultArray& add(const OtherArray& other, ResultArray& result,
Enabled = 0) const {
validateDimensions_("Array \"other\"", other.dimensions(),
PISTIS_EX_HERE);
validateDimensions_("Array \"result\"", result.dimensions(),
PISTIS_EX_HERE);
detail::MklAdapter<Field, typename OtherArray::FieldType>::add(
this->size(), this->data(), other.data(), result.data()
);
return result;
}
template <typename OtherArray,
typename Enabled =
typename std::enable_if<IsMdArray<OtherArray>::value,
int
>::type
>
DerivedArray& addInPlace(const OtherArray& other, Enabled = 0) {
return this->add(other, this->self());
}
template <typename OtherArray,
typename Enabled =
typename std::enable_if<
IsMdArray<OtherArray>::value, NewArray
>::type
>
Enabled scaleAndAdd(Field c, const OtherArray& other) const {
validateDimensions_("Array \"other\"", other.dimensions(),
PISTIS_EX_HERE);
NewArray result(this->self());
return std::move(result.scaleAndAddInPlace(c, other));
}
template <typename OtherArray,
typename ResultArray,
typename Enabled =
typename std::enable_if<
IsMdArray<OtherArray>::value &&
IsMdArray<ResultArray>::value,
ResultArray
>::type
>
Enabled& scaleAndAdd(Field c, const OtherArray& other,
ResultArray& result) const {
validateDimensions_("Array \"other\"", other.dimensions(),
PISTIS_EX_HERE);
validateDimensions_("Array \"result\"", result.dimensions(),
PISTIS_EX_HERE);
result = this->self();
return result.scaleAndAddInPlace(c, other);
}
template <typename OtherArray,
typename Enabled =
typename std::enable_if<
IsMdArray<OtherArray>::value, int
>::type
>
DerivedArray& scaleAndAddInPlace(Field c, const OtherArray& other,
Enabled = 0) {
validateDimensions_("Array \"other\"", other.dimensions(),
PISTIS_EX_HERE);
detail::MklAdapter<Field, typename OtherArray::FieldType>::scaleAndAdd(
this->size(), c, other.data(), this->data()
);
return this->self();
}
template <typename OtherArray,
typename Enabled =
typename std::enable_if<
IsMdArray<OtherArray>::value, NewArray
>::type
>
Enabled scaleAndAdd(Field c1, Field c2,
const OtherArray& other) const {
validateDimensions_("Array \"other\"", other.dimensions(),
PISTIS_EX_HERE);
NewArray result(this->self());
return std::move(result.scaleAndAddInPlace(c1, c2, other));
}
template <typename OtherArray,
typename ResultArray,
typename Enabled =
typename std::enable_if<
IsMdArray<OtherArray>::value &&
IsMdArray<ResultArray>::value,
int
>::type
>
ResultArray& scaleAndAdd(Field c1, Field c2, const OtherArray& other,
ResultArray& result, Enabled = 0) const {
validateDimensions_("Array \"other\"", other.dimensions(),
PISTIS_EX_HERE);
validateDimensions_("Array \"result\"", result.dimensions(),
PISTIS_EX_HERE);
result = this->self();
return result.scaleAndAddInPlace(c1, c2, other);
}
template <typename OtherArray,
typename Enabled =
typename std::enable_if<IsMdArray<OtherArray>::value,
int
>::type
>
DerivedArray& scaleAndAddInPlace(Field c1, Field c2,
const OtherArray& other,
Enabled = 0) {
validateDimensions_("Array \"other\"", other.dimensions(),
PISTIS_EX_HERE);
detail::MklAdapter<Field, typename OtherArray::FieldType>::scaleAndAdd(
this->size(), c2, other.data(), c1, this->data()
);
return this->self();
}
template <typename OtherArray,
typename Enabled =
typename std::enable_if<
IsMdArray<OtherArray>::value, NewArray
>::type
>
Enabled subtract(const OtherArray& other) const {
validateDimensions_("array \"other\"", other.dimensions(),
PISTIS_EX_HERE);
NewArray result(dimensions(), allocator());
return std::move(this->subtract(other, result));
}
template <typename OtherArray,
typename ResultArray,
typename Enabled =
typename std::enable_if<
IsMdArray<OtherArray>::value &&
IsMdArray<ResultArray>::value,
int
>::type
>
ResultArray& subtract(const OtherArray& other, ResultArray& result,
Enabled = 0) const {
validateDimensions_("array \"other\"", other.dimensions(),
PISTIS_EX_HERE);
validateDimensions_("array \"result\"", result.dimensions(),
PISTIS_EX_HERE);
detail::MklAdapter<Field, typename OtherArray::FieldType>::subtract(
this->size(), this->data(), other.data(), result.data()
);
return result;
}
template <typename OtherArray,
typename Enabled =
typename std::enable_if<IsMdArray<OtherArray>::value,
int>::type
>
DerivedArray& subtractInPlace(const OtherArray& other, Enabled = 0) {
return this->subtract(other, this->self());
}
template <typename OtherArray,
typename Enabled =
typename std::enable_if<
IsMdArray<OtherArray>::value, NewArray
>::type
>
Enabled multiply(const OtherArray& other) const {
validateDimensions_("array \"other\"", other.dimensions(),
PISTIS_EX_HERE);
NewArray result(dimensions(), allocator());
return std::move(this->multiply(other, result));
}
template <typename OtherArray,
typename ResultArray,
typename Enabled =
typename std::enable_if<
IsMdArray<OtherArray>::value &&
IsMdArray<ResultArray>::value,
int
>::type
>
ResultArray& multiply(const OtherArray& other, ResultArray& result,
Enabled = 0) const {
validateDimensions_("array \"other\"", other.dimensions(),
PISTIS_EX_HERE);
validateDimensions_("array \"result\"", result.dimensions(),
PISTIS_EX_HERE);
detail::MklAdapter<Field, typename OtherArray::FieldType>::multiply(
this->size(), this->data(), other.data(), result.data()
);
return result;
}
template <typename OtherArray,
typename Enabled =
typename std::enable_if<IsMdArray<OtherArray>::value,
int>::type
>
DerivedArray& multiplyInPlace(const OtherArray& other, Enabled = 0) {
return this->multiply(other, this->self());
}
NewArray multiply(Field c) const {
NewArray result(this->self());
return std::move(result.multiplyInPlace(c));
}
template <typename ResultArray,
typename Enabled =
typename std::enable_if<IsMdArray<ResultArray>::value,
int>::type
>
ResultArray& multiply(Field c, ResultArray& result) const {
validateDimensions_("Array \"result\"", result.dimensions(),
PISTIS_EX_HERE);
result = this->self();
return result.multiplyInPlace(c);
}
DerivedArray& multiplyInPlace(Field c) {
detail::MklAdapter<Field, Field>::scale(this->size(), c,
this->data());
return this->self();
}
template <typename OtherArray,
typename Enabled =
typename std::enable_if<
IsMdArray<OtherArray>::value, DerivedArray
>::type
>
Enabled divide(const OtherArray& other) const {
validateDimensions_("array \"other\"", other.dimensions(),
PISTIS_EX_HERE);
NewArray result(dimensions(), allocator());
return std::move(this->divide(other, result));
}
template <typename OtherArray,
typename ResultArray,
typename Enabled =
typename std::enable_if<
IsMdArray<OtherArray>::value &&
IsMdArray<ResultArray>::value,
int
>::type
>
ResultArray& divide(const OtherArray& other, ResultArray& result,
Enabled = 0) const {
validateDimensions_("array \"other\"", other.dimensions(),
PISTIS_EX_HERE);
validateDimensions_("array \"result\"", result.dimensions(),
PISTIS_EX_HERE);
detail::MklAdapter<Field, typename OtherArray::FieldType>::divide(
this->size(), this->data(), other.data(), result.data()
);
return result;
}
template <typename OtherArray,
typename Enabled =
typename std::enable_if<
IsMdArray<OtherArray>::value, int
>::type
>
DerivedArray& divideInPlace(const OtherArray& other, Enabled = 0) {
return this->divide(other, this->self());
}
template <typename Vector,
typename Enabled =
typename std::enable_if<
IsMdArray<Vector>::value && (Vector::ORDER == 1),
InnerProductResult
>::type
>
Enabled innerProduct(const Vector& v) const {
this->validateInnerProductArgDimensions_("Vector \"v\"",
v.dimensions(),
PISTIS_EX_HERE);
DimensionListType resultDimensions(
this->dimensions().butLast(1)
);
InnerProductResult result(resultDimensions, this->allocator());
return std::move(this->self().innerProduct(v, result));
}
template <typename Vector,
typename Enabled =
typename std::enable_if<
IsMdArray<Vector>::value && (Vector::ORDER == 1),
InnerProductResult
>::type
>
Enabled transposeInnerProduct(const Vector& v) const {
this->validateTransposeInnerProductArgDimensions_("Vector \"v\"",
v.dimensions(),
PISTIS_EX_HERE);
const DimensionListType resultDimensions =
this->dimensions().remove(this->dimensions().size() - 2);
InnerProductResult result(resultDimensions, this->allocator());
return std::move(this->self().transposeInnerProduct(v, result));
}
template <typename Matrix,
typename Enabled =
typename std::enable_if<
IsMdArray<Matrix>::value && (Matrix::ORDER == 2),
NewArray
>::type
>
Enabled matrixProduct(const Matrix& m) const {
this->validateMatrixProductArgDimensions_("Matrix \"m\"",
m.dimensions(),
PISTIS_EX_HERE);
DimensionListType resultDimensions(
this->dimensions().replaceLast(m.dimensions()[1])
);
NewArray result(resultDimensions, this->allocator());
return std::move(this->self().matrixProduct(m, result));
}
template <typename Function>
NewArray map(const Function& f) const {
NewArray result(this->dimensions(), this->allocator());
return std::move(this->map(f, result));
}
template <typename Function, typename ResultArray,
typename Enabled =
typename std::enable_if<
IsMdArray<ResultArray>::value &&
(ResultArray::ORDER == ARRAY_ORDER),
ResultArray
>::type
>
Enabled& map(const Function& f, ResultArray& result) const {
if (result.dimensions() != this->dimensions()) {
std::ostringstream msg;
msg << "Array \"result\" has incorrect dimensions "
<< result.dimensions() << " -- it should have dimensions "
<< this->dimensions();
throw pistis::exceptions::IllegalValueError(msg.str(),
PISTIS_EX_HERE);
}
auto p = this->data();
auto q = result.data();
#pragma omp parallel for
{
for (size_t i = 0; i < this->size(); ++i) {
q[i] = f(p[i]);
}
}
return result;
}
template <typename Function>
DerivedArray& mapInPlace(Function f) {
return this->map(f, this->self());
}
// const SliceType operator[](size_t n) const {
// return self()->slice_(n);
// }
// SliceType operator[](size_t n) {
// return self()->slice_(n);
// }
protected:
void validateDimensions_(
const std::string& name,
const DimensionListType& d,
const pistis::exceptions::ExceptionOrigin& origin
) const {
if (d != this->dimensions()) {
std::ostringstream msg;
msg << name << " has incorrect dimensions " << d
<< ". It should have dimensions " << this->dimensions();
throw pistis::exceptions::IllegalValueError(msg.str(), origin);
}
}
void validateInnerProductArgDimensions_(
const std::string& name,
const DimensionListType& dimensions,
const pistis::exceptions::ExceptionOrigin& origin
) const {
const size_t lastDimension = this->dimensions().back();
if ((dimensions.size() != 1) || (dimensions[0] != lastDimension)) {
std::ostringstream msg;
msg << name << " has dimensions " << dimensions
<< ", but it should have dimension [ " << lastDimension
<< " ]";
throw pistis::exceptions::IllegalValueError(msg.str(), origin);
}
}
void validateInnerProductResultDimensions_(
const std::string& name,
const DimensionListType& dimensions,
const pistis::exceptions::ExceptionOrigin& origin
) const {
const DimensionListType targetDimensions =
this->dimensions().butLast(1);
if (dimensions != targetDimensions) {
std::ostringstream msg;
msg << name << " has dimensions " << dimensions
<< ", but it should have dimensions " << targetDimensions;
throw pistis::exceptions::IllegalValueError(msg.str(), origin);
}
}
void validateMatrixProductArgDimensions_(
const std::string& name,
const DimensionListType& dimensions,
const pistis::exceptions::ExceptionOrigin& origin
) const {
if (dimensions.size() != 2) {
std::ostringstream msg;
msg << name << " is not a matrix. It is an array with order "
<< dimensions.size();
throw pistis::exceptions::IllegalValueError(msg.str(), origin);
}
if (dimensions[0] != this->self().dimensions().back()) {
std::ostringstream msg;
msg << name << " has incorrect dimensions " << dimensions
<< " -- the first dimension must match the last dimension"
<< " of this array (which is "
<< this->self().dimensions().back() << ")";
throw pistis::exceptions::IllegalValueError(msg.str(), origin);
}
}
void validateMatrixProductResultDimensions_(
const std::string& name,
const DimensionListType& argDimensions,
const DimensionListType& resultDimensions,
const pistis::exceptions::ExceptionOrigin& origin
) const {
const DimensionListType targetDimensions =
this->self().dimensions().replaceLast(argDimensions[1]);
if (resultDimensions != targetDimensions) {
std::ostringstream msg;
msg << name << " has incorrect dimensions " << targetDimensions
<< " -- it should have dimensions " << resultDimensions;
throw pistis::exceptions::IllegalValueError(msg.str(), origin);
}
}
void validateOuterProductDimensions_(
const std::string& name,
const DimensionListType& argDimensions,
const DimensionListType& resultDimensions,
const pistis::exceptions::ExceptionOrigin& origin
) const {
const DimensionListType targetDimensions =
argDimensions.insert(argDimensions.size() - 1,
this->self().dimensions().back());
if (targetDimensions != resultDimensions) {
std::ostringstream msg;
msg << name << " has incorrect dimensions " << resultDimensions
<< " -- it should have dimensions " << targetDimensions;
throw pistis::exceptions::IllegalValueError(msg.str(), origin);
}
}
void validateTransposeInnerProductArgDimensions_(
const std::string& name,
const DimensionListType& argDimensions,
const pistis::exceptions::ExceptionOrigin& origin
) const {
if (this->self().dimensions().back(1) != argDimensions.front()) {
std::ostringstream msg;
msg << name << " has incorrect dimensions " << argDimensions
<< " -- it should have dimensions [ "
<< this->self().dimensions().back(1) << " ]";
throw pistis::exceptions::IllegalValueError(msg.str(), origin);
}
}
void validateTransposeInnerProductResultDimensions_(
const std::string& name,
const DimensionListType& argDimensions,
const DimensionListType& resultDimensions,
const pistis::exceptions::ExceptionOrigin& origin
) const {
const size_t n = this->self().dimensions().size();
const DimensionListType targetDimensions =
this->self().dimensions().remove(n - 2);
if (targetDimensions != resultDimensions) {
std::ostringstream msg;
msg << name << " has incorrect dimensions " << resultDimensions
<< " -- it should have dimensions " << targetDimensions;
throw pistis::exceptions::IllegalValueError(msg.str(), origin);
}
}
};
}
}
}
}
#endif
| 32.646179
| 76
| 0.630235
|
tomault
|
6c512fe4376cea6471f0a497a0d39039b8606b8d
| 6,256
|
cpp
|
C++
|
Engine/ModuleResource.cpp
|
Beautiful-Engines/Engine
|
fab1b2415d63218078cc6f2b2a33676e9ef45543
|
[
"MIT"
] | null | null | null |
Engine/ModuleResource.cpp
|
Beautiful-Engines/Engine
|
fab1b2415d63218078cc6f2b2a33676e9ef45543
|
[
"MIT"
] | null | null | null |
Engine/ModuleResource.cpp
|
Beautiful-Engines/Engine
|
fab1b2415d63218078cc6f2b2a33676e9ef45543
|
[
"MIT"
] | null | null | null |
#include "Application.h"
#include "ModuleFileSystem.h"
#include "ModuleImport.h"
#include "ModuleResource.h"
#include "ModuleScene.h"
#include "ImportMesh.h"
#include "ResourceMesh.h"
#include "ImportTexture.h"
#include "ResourceTexture.h"
#include "ImportModel.h"
#include "ResourceModel.h"
#include "ImportAnimation.h"
#include "ResourceAnimation.h"
#include "ResourceBone.h"
#include "Primitive.h"
#include <fstream>
ModuleResource::ModuleResource(bool start_enabled) : Module(start_enabled)
{
name = "Resource";
}
ModuleResource::~ModuleResource()
{
}
bool ModuleResource::Start()
{
LOG("importing all assets");
return true;
}
Resource* ModuleResource::CreateResource(const char* extension, uint UID)
{
Resource* r = nullptr;
if (extension == OUR_MESH_EXTENSION)
{
r = new ResourceMesh();
}
else if (extension == OUR_TEXTURE_EXTENSION)
{
r = new ResourceTexture();
}
else if (extension == OUR_MODEL_EXTENSION)
{
r = new ResourceModel();
}
else if (extension == OUR_ANIMATION_EXTENSION)
{
r = new ResourceAnimation();
}
else if (extension == OUR_BONE_EXTENSION)
{
r = new ResourceBone();
}
if (r != nullptr && UID != 0)
{
r->SetId(UID);
}
if (r != nullptr)
resources.emplace(r->GetId(), r);
return r;
}
Resource* ModuleResource::Get(uint _UID)
{
std::map<uint, Resource*>::iterator it = resources.find(_UID);
if (it != resources.end())
return it->second;
return nullptr;
}
Resource* ModuleResource::GetAndUse(uint _UID)
{
std::map<uint, Resource*>::iterator it = resources.find(_UID);
if (it != resources.end())
{
it->second->SetCantities(1);
return it->second;
}
return nullptr;
}
uint ModuleResource::GetId(std::string _file)
{
for (std::map<uint, Resource*>::iterator it = resources.begin(); it != resources.end(); ++it)
{
if (it->second->GetName() == _file)
return it->first;
}
return 0;
}
std::map<uint, Resource*> ModuleResource::GetResources()
{
return resources;
}
void ModuleResource::LoadAllAssets()
{
App->importer->import_texture->DefaultTexture();
LoadByFolder(ASSETS_FOLDER);
// just for delivery, then delete it
std::string path = "skeleton@idle.fbx";
path = ASSETS_FOLDER + path;
GameObject* go = App->importer->import_model->CreateModel((ResourceModel*)App->resource->GetAndUse(App->resource->GetId(path.c_str())));
go->SetStatic(false);
go->GetTransform()->SetLocalScale({ 0.3, 0.3, 0.3 });
go->SetStatic(true);
path = "skeleton@attack.fbx";
path = ASSETS_FOLDER + path;
go = App->importer->import_model->CreateModel((ResourceModel*)App->resource->GetAndUse(App->resource->GetId(path.c_str())));
path = "skeleton@run.fbx";
path = ASSETS_FOLDER + path;
go = App->importer->import_model->CreateModel((ResourceModel*)App->resource->GetAndUse(App->resource->GetId(path.c_str())));
path = "street environment_v01.fbx";
path = ASSETS_FOLDER + path;
App->importer->import_model->CreateModel((ResourceModel*)App->resource->GetAndUse(App->resource->GetId(path.c_str())));
}
void ModuleResource::LoadByFolder(const char* _folder)
{
std::vector<std::string> files_temp;
std::vector<std::string> files;
std::vector<std::string> directories;
App->file_system->DiscoverFiles(_folder, files_temp, directories);
for (int i = 0; i < files_temp.size(); ++i)
{
if (files_temp[i].find(".meta") > 1000)
files.push_back(files_temp[i]);
}
std::vector<std::string>::iterator iterator = files.begin();
for (; iterator != files.end(); ++iterator)
{
if (first_textures && (*iterator).find(".fbx") > 1000)
{
App->file_system->SplitFilePath((*iterator).c_str(), nullptr, nullptr);
App->importer->ImportFile((_folder + (*iterator)).c_str(), false, true);
}
else if (!first_textures && (*iterator).find(".fbx") < 1000)
{
App->file_system->SplitFilePath((*iterator).c_str(), nullptr, nullptr);
App->importer->ImportFile((_folder + (*iterator)).c_str(), false, true);
}
}
std::vector<std::string>::iterator iterator2 = directories.begin();
for (; iterator2 != directories.end(); ++iterator2)
{
std::string folder = _folder + (*iterator2) + "/";
LoadByFolder(folder.c_str());
}
if (first_textures)
{
first_textures = false;
LoadByFolder(ASSETS_FOLDER);
}
}
void ModuleResource::LoadFile(const char * _path)
{
if (!App->resource->GetId(_path))
{
std::string spath = _path;
std::ifstream ifstream(spath);
nlohmann::json json = nlohmann::json::parse(ifstream);
uint UID = json["id"];
std::string exported_file = json["exported_file"];
std::string name = json["name"];
std::string extension;
App->file_system->SplitFilePath(exported_file.c_str(), nullptr, nullptr, &extension);
Resource *resource = nullptr;
if ("." + extension == OUR_MESH_EXTENSION)
{
resource = CreateResource(OUR_MESH_EXTENSION, UID);
resource->SetFile(exported_file);
resource->SetName(name);
App->importer->import_mesh->LoadMeshFromResource((ResourceMesh*)resource);
}
else if ("." + extension == OUR_TEXTURE_EXTENSION)
{
resource = CreateResource(OUR_TEXTURE_EXTENSION, UID);
resource->SetName(name);
App->importer->import_texture->LoadTexture(exported_file.c_str(), nullptr, (ResourceTexture*)resource);
}
else if ("." + extension == OUR_MODEL_EXTENSION)
{
resource = CreateResource(OUR_MODEL_EXTENSION, UID);
resource->SetFile(exported_file);
resource->SetName(name);
ResourceModel* resource_model = (ResourceModel*)resource;
for (nlohmann::json::iterator iterator = json.find("animations").value().begin(); iterator != json.find("animations").value().end(); ++iterator)
{
resource_model->animations.push_back((*iterator)["id"]);
}
App->importer->import_model->LoadModel(resource_model);
}
else if ("." + extension == OUR_ANIMATION_EXTENSION)
{
resource = CreateResource(OUR_ANIMATION_EXTENSION, UID);
resource->SetFile(exported_file);
resource->SetName(name);
App->importer->import_animation->LoadAnimationFromResource((ResourceAnimation*)resource);
}
else if ("." + extension == OUR_BONE_EXTENSION)
{
resource = CreateResource(OUR_BONE_EXTENSION, UID);
resource->SetFile(exported_file);
resource->SetName(name);
App->importer->import_animation->LoadBoneFromResource((ResourceBone*)resource);
}
}
}
| 26.621277
| 147
| 0.69773
|
Beautiful-Engines
|
6c5eb48d870b5a346b660c506c4be01414158af2
| 923
|
cpp
|
C++
|
GL/ShootingGame/Circle.cpp
|
KoreanGinseng/CreativeLabo4
|
a7c03ad2cea958be1509cd0c09581b1f4fc81275
|
[
"MIT"
] | null | null | null |
GL/ShootingGame/Circle.cpp
|
KoreanGinseng/CreativeLabo4
|
a7c03ad2cea958be1509cd0c09581b1f4fc81275
|
[
"MIT"
] | null | null | null |
GL/ShootingGame/Circle.cpp
|
KoreanGinseng/CreativeLabo4
|
a7c03ad2cea958be1509cd0c09581b1f4fc81275
|
[
"MIT"
] | null | null | null |
#include "Circle.h"
Circle::Circle()
: x_(0.0f)
, y_(0.0f)
, r_(0.0f) {
}
Circle::Circle(float r)
: x_(0.0f)
, y_(0.0f)
, r_(r) {
}
Circle::Circle(float x, float y, float r)
: x_(x)
, y_(y)
, r_(r) {
}
Circle::~Circle() {
}
bool Circle::CollisionPoint(float x, float y) const {
float distanceX = std::fabsf(x_ - x);
float distanceY = std::fabsf(y_ - y);
float distance = std::powf(distanceX, 2) + std::powf(distanceY, 2);
return distance <= std::powf(r_, 2);
}
bool Circle::CollisionCircle(float x, float y, float r) const {
float distanceX = std::fabsf(x_ - x);
float distanceY = std::fabsf(y_ - y);
float distance = std::powf(distanceX, 2) + std::powf(distanceY, 2);
return distance <= std::powf(r_, 2) + std::powf(r, 2);
}
bool Circle::CollisionCircle(Circle circle) const {
return CollisionCircle(circle.x(), circle.y(), circle.r());
}
| 22.512195
| 72
| 0.592633
|
KoreanGinseng
|
4842baec0e2e73ef3a1cb88c9df2b3ea3b356420
| 11,422
|
cpp
|
C++
|
AmbientGsm.cpp
|
mnltake/ambient_gpstracker_LTE
|
57d28327e4f47cc82ddff80796b3686ffd6a0014
|
[
"MIT"
] | null | null | null |
AmbientGsm.cpp
|
mnltake/ambient_gpstracker_LTE
|
57d28327e4f47cc82ddff80796b3686ffd6a0014
|
[
"MIT"
] | null | null | null |
AmbientGsm.cpp
|
mnltake/ambient_gpstracker_LTE
|
57d28327e4f47cc82ddff80796b3686ffd6a0014
|
[
"MIT"
] | null | null | null |
/*
* ambient.cpp - Library for sending data to Ambient
* Created by Takehiko Shimojima, April 21, 2016
* change by mnltake ,2022
*/
#include "AmbientGsm.h"
#define AMBIENT_DEBUG 0
#if AMBIENT_DEBUG
#define DBG(...) { Serial.print(__VA_ARGS__); }
#define ERR(...) { Serial.print(__VA_ARGS__); }
#else
#define DBG(...)
#define ERR(...)
#endif /* AMBIENT_DBG */
// const char* AMBIENT_HOST = "54.65.206.59";
const char* AMBIENT_HOST = "ambidata.io";
int AMBIENT_PORT = 80;
const char* AMBIENT_HOST_DEV = "192.168.11.2";
int AMBIENT_PORT_DEV = 4567;
const char * ambient_keys[] = {"\"d1\":\"", "\"d2\":\"", "\"d3\":\"", "\"d4\":\"", "\"d5\":\"", "\"d6\":\"", "\"d7\":\"", "\"d8\":\"", "\"lat\":\"", "\"lng\":\"", "\"created\":\""};
Ambient::Ambient() {
}
bool
Ambient::begin(unsigned int channelId, const char * writeKey, TinyGsmClient * c, const char * readKey, int dev) {
this->channelId = channelId;
if (sizeof(writeKey) > AMBIENT_WRITEKEY_SIZE) {
ERR("writeKey length > AMBIENT_WRITEKEY_SIZE");
return false;
}
strcpy(this->writeKey, writeKey);
if(NULL == c) {
ERR("Socket Pointer is NULL, open a socket.");
return false;
}
this->client = c;
if (readKey != NULL) {
strcpy(this->readKey, readKey);
} else {
strcpy(this->readKey, "");
}
this->dev = dev;
if (dev) {
strcpy(this->host, AMBIENT_HOST_DEV);
this->port = AMBIENT_PORT_DEV;
} else {
strcpy(this->host, AMBIENT_HOST);
this->port = AMBIENT_PORT;
}
for (int i = 0; i < AMBIENT_NUM_PARAMS; i++) {
this->data[i].set = false;
}
this->cmnt.set = false;
return true;
}
bool
Ambient::set(int field,const char * data) {
--field;
if (field < 0 || field >= AMBIENT_NUM_PARAMS) {
return false;
}
if (strlen(data) > AMBIENT_DATA_SIZE) {
return false;
}
this->data[field].set = true;
strcpy(this->data[field].item, data);
return true;
}
bool Ambient::set(int field, double data)
{
return set(field,String(data).c_str());
}
bool Ambient::set(int field, int data)
{
return set(field, String(data).c_str());
}
bool
Ambient::clear(int field) {
--field;
if (field < 0 || field >= AMBIENT_NUM_PARAMS) {
return false;
}
this->data[field].set = false;
this->cmnt.set = false;
return true;
}
bool
Ambient::setcmnt(const char * data) {
if (strlen(data) > AMBIENT_CMNT_SIZE) {
return false;
}
this->cmnt.set = true;
strcpy(this->cmnt.item, data);
return true;
}
bool Ambient::connect2host(uint32_t tmout) {
int retry;
for (retry = 0; retry < AMBIENT_MAX_RETRY; retry++) {
int ret;
#if defined(ESP8266)
this->client->setTimeout(tmout);
ret = this->client->connect(this->host, this->port);
#else
ret = this->client->connect(this->host, this->port);
#endif
if (ret) {
break ;
}
}
if(retry == AMBIENT_MAX_RETRY) {
ERR("Could not connect socket to host\r\n");
return false;
}
return true;
}
int
Ambient::getStatusCode() {
String _buf = this->client->readStringUntil('\n');
int from = _buf.indexOf("HTTP/1.1 ") + sizeof("HTTP/1.1 ") - 1;
int to = _buf.indexOf(' ', from);
this->status = _buf.substring(from, to).toInt();
return this->status;
}
bool
Ambient::send(uint32_t tmout) {
char str[180];
char body[192];
char inChar;
this->status = 0;
if (connect2host(tmout) == false) {
return false;
}
memset(body, 0, sizeof(body));
strcat(body, "{\"writeKey\":\"");
strcat(body, this->writeKey);
strcat(body, "\",");
for (int i = 0; i < AMBIENT_NUM_PARAMS; i++) {
if (this->data[i].set) {
strcat(body, ambient_keys[i]);
strcat(body, this->data[i].item);
strcat(body, "\",");
}
}
if (this->cmnt.set) {
strcat(body, "\"cmnt\":\"");
strcat(body, this->cmnt.item);
strcat(body, "\",");
}
body[strlen(body) - 1] = '\0';
strcat(body, "}\r\n");
memset(str, 0, sizeof(str));
sprintf(str, "POST /api/v2/channels/%u/data HTTP/1.1\r\n", this->channelId);
if (this->port == 80) {
sprintf(&str[strlen(str)], "Host: %s\r\n", this->host);
} else {
sprintf(&str[strlen(str)], "Host: %s:%d\r\n", this->host, this->port);
}
sprintf(&str[strlen(str)], "Content-Length: %d\r\n", strlen(body));
sprintf(&str[strlen(str)], "Content-Type: application/json\r\n\r\n");
DBG("sending: ");DBG(strlen(str));DBG("bytes\r\n");DBG(str);
int ret;
ret = this->client->print(str);
delay(30);
DBG(ret);DBG(" bytes sent\n\n");
if (ret == 0) {
ERR("send failed\n");
return false;
}
ret = this->client->print(body);
delay(30);
DBG(ret);DBG(" bytes sent\n\n");
if (ret == 0) {
ERR("send failed\n");
return false;
}
getStatusCode();
while (this->client->available()) {
inChar = this->client->read();
#if AMBIENT_DEBUG
Serial.write(inChar);
#endif
}
this->client->stop();
for (int i = 0; i < AMBIENT_NUM_PARAMS; i++) {
this->data[i].set = false;
}
this->cmnt.set = false;
return true;
}
int
Ambient::bulk_send(char *buf, uint32_t tmout) {
char str[180];
char inChar;
this->status = 0;
if (connect2host(tmout) == false) {
return false;
}
memset(str, 0, sizeof(str));
sprintf(str, "POST /api/v2/channels/%u/dataarray HTTP/1.1\r\n", this->channelId);
if (this->port == 80) {
sprintf(&str[strlen(str)], "Host: %s\r\n", this->host);
} else {
sprintf(&str[strlen(str)], "Host: %s:%d\r\n", this->host, this->port);
}
sprintf(&str[strlen(str)], "Content-Length: %d\r\n", strlen(buf));
sprintf(&str[strlen(str)], "Content-Type: application/json\r\n\r\n");
DBG("sending: ");DBG(strlen(str));DBG("bytes\r\n");DBG(str);
int ret;
ret = this->client->print(str); // send header
delay(30);
DBG(ret);DBG(" bytes sent\n\n");
if (ret == 0) {
ERR("send failed\n");
return -1;
}
int sent = 0;
unsigned long starttime = millis();
while ((millis() - starttime) < AMBIENT_TIMEOUT) {
ret = this->client->print(&buf[sent]);
delay(30);
DBG(ret);DBG(" bytes sent\n\n");
if (ret == 0) {
ERR("send failed\n");
return -1;
}
sent += ret;
if (sent >= strlen(buf)) {
break;
}
}
delay(500);
getStatusCode();
while (this->client->available()) {
inChar = this->client->read();
#if AMBIENT_DEBUG
Serial.write(inChar);
#endif
}
this->client->stop();
for (int i = 0; i < AMBIENT_NUM_PARAMS; i++) {
this->data[i].set = false;
}
this->cmnt.set = false;
return (sent == 0) ? -1 : sent;
}
bool
Ambient::read(char * buf, int len, int n, uint32_t tmout) {
char str[180];
String _buf;
this->status = 0;
if (connect2host(tmout) == false) {
return false;
}
memset(str, 0, sizeof(str));
sprintf(str, "GET /api/v2/channels/%u/data?readKey=%s&n=%d HTTP/1.1\r\n", this->channelId, this->readKey, n);
if (this->port == 80) {
sprintf(&str[strlen(str)], "Host: %s\r\n\r\n", this->host);
} else {
sprintf(&str[strlen(str)], "Host: %s:%d\r\n\r\n", this->host, this->port);
}
DBG("sending: ");DBG(strlen(str));DBG("bytes\r\n");DBG(str);
int ret;
ret = this->client->print(str);
delay(30);
DBG(ret);DBG(" bytes sent\n\n");
if (ret == 0) {
ERR("send failed\n");
return false;
}
if (getStatusCode() != 200) { // ステータスコードが200でなければ
while (this->client->available()) { // 残りを読み捨てる
this->client->readStringUntil('\n');
}
return false;
}
while (this->client->available()) {
_buf = this->client->readStringUntil('\n');
if (_buf.length() == 1) // 空行を見つける
break;
}
_buf = this->client->readStringUntil('\n');
_buf.toCharArray(buf, len);
this->client->stop();
return true;
}
bool
Ambient::delete_data(const char * userKey, uint32_t tmout) {
char str[180];
char inChar;
this->status = 0;
if (connect2host(tmout) == false) {
return false;
}
memset(str, 0, sizeof(str));
sprintf(str, "DELETE /api/v2/channels/%u/data?userKey=%s HTTP/1.1\r\n", this->channelId, userKey);
if (this->port == 80) {
sprintf(&str[strlen(str)], "Host: %s\r\n", this->host);
} else {
sprintf(&str[strlen(str)], "Host: %s:%d\r\n", this->host, this->port);
}
sprintf(&str[strlen(str)], "Content-Length: 0\r\n");
sprintf(&str[strlen(str)], "Content-Type: application/json\r\n\r\n");
DBG(str);
int ret;
ret = this->client->print(str);
delay(30);
DBG(ret);DBG(" bytes sent\r\n");
if (ret == 0) {
ERR("send failed\r\n");
return false;
}
getStatusCode();
while (this->client->available()) {
inChar = this->client->read();
#if AMBIENT_DEBUG
Serial.write(inChar);
#endif
}
this->client->stop();
for (int i = 0; i < AMBIENT_NUM_PARAMS; i++) {
this->data[i].set = false;
}
this->cmnt.set = false;
return true;
}
bool
Ambient::getchannel(const char * userKey, const char * devKey, unsigned int & channelId, char * writeKey, int len, TinyGsmClient * c, uint32_t tmout, int dev) {
this->status = 0;
if(NULL == c) {
ERR("Socket Pointer is NULL, open a socket.");
return false;
}
this->client = c;
this->dev = dev;
if (dev) {
strcpy(this->host, AMBIENT_HOST_DEV);
this->port = AMBIENT_PORT_DEV;
} else {
strcpy(this->host, AMBIENT_HOST);
this->port = AMBIENT_PORT;
}
if (connect2host(tmout) == false) {
return false;
}
char str[1024];
char inChar;
memset(str, 0, sizeof(str));
sprintf(str, "GET /api/v2/channels/?userKey=%s&devKey=%s HTTP/1.1\r\n", userKey, devKey);
if (this->port == 80) {
sprintf(&str[strlen(str)], "Host: %s\r\n", this->host);
} else {
sprintf(&str[strlen(str)], "Host: %s:%d\r\n", this->host, this->port);
}
sprintf(&str[strlen(str)], "Content-Type: application/json\r\n\r\n");
DBG(str);
int ret;
ret = this->client->print(str);
delay(30);
DBG(ret);DBG(" bytes sent\r\n");
if (ret == 0) {
ERR("send failed\r\n");
return false;
}
if (getStatusCode() != 200) { // ステータスコードが200でなければ
while (this->client->available()) {
this->client->readStringUntil('\n');
}
return false;
}
while (this->client->available()) {
String buf = this->client->readStringUntil('\n');
if (buf.length() == 1)
break;
}
String buf = this->client->readStringUntil('\n');
int from, to;
from = buf.indexOf("\"ch\":\"") + strlen("\"ch\":\"");
to = buf.indexOf("\",", from);
channelId = buf.substring(from, to).toInt();
from = buf.indexOf("\"writeKey\":\"") + strlen("\"writeKey\":\"");
to = buf.indexOf("\",", from);
buf.substring(from, to).toCharArray(writeKey, len);
this->client->stop();
return true;
}
| 25.667416
| 181
| 0.548941
|
mnltake
|
4842c77d1d750453454405dd78d347cea6c68375
| 7,954
|
hpp
|
C++
|
include/mtx/responses/crypto.hpp
|
govynnus/mtxclient
|
3888ae70d51cdfe7b69d375560448f36991793e6
|
[
"MIT"
] | 18
|
2019-03-11T20:23:53.000Z
|
2022-02-25T20:55:27.000Z
|
include/mtx/responses/crypto.hpp
|
govynnus/mtxclient
|
3888ae70d51cdfe7b69d375560448f36991793e6
|
[
"MIT"
] | 55
|
2019-02-07T01:21:03.000Z
|
2022-03-06T15:42:34.000Z
|
include/mtx/responses/crypto.hpp
|
govynnus/mtxclient
|
3888ae70d51cdfe7b69d375560448f36991793e6
|
[
"MIT"
] | 22
|
2019-02-24T17:28:31.000Z
|
2022-03-10T22:40:22.000Z
|
#pragma once
/// @file
/// @brief E2EE related endpoints.
#if __has_include(<nlohmann/json_fwd.hpp>)
#include <nlohmann/json_fwd.hpp>
#else
#include <nlohmann/json.hpp>
#endif
#include "mtx/common.hpp"
#include "mtx/lightweight_error.hpp"
#include <map>
#include <string>
namespace mtx {
namespace responses {
//! Response from the `POST /_matrix/client/r0/keys/upload` endpoint.
struct UploadKeys
{
//! For each key algorithm, the number of unclaimed one-time keys
//! of that type currently held on the server for this device.
std::map<std::string, uint32_t> one_time_key_counts;
};
void
from_json(const nlohmann::json &obj, UploadKeys &response);
using DeviceToKeysMap = std::map<std::string, mtx::crypto::DeviceKeys>;
//! Response from the `POST /_matrix/client/r0/keys/query` endpoint.
struct QueryKeys
{
//! If any remote homeservers could not be reached, they are
//! recorded here. The names of the properties are the names
//! of the unreachable servers.
std::map<std::string, nlohmann::json> failures;
//! Information on the queried devices.
//! A map from user ID, to a map from device ID to device information.
//! For each device, the information returned will be the same
//! as uploaded via /keys/upload, with the addition of an unsigned property
std::map<std::string, DeviceToKeysMap> device_keys;
//! A map from user ID, to information about master_keys.
std::map<std::string, mtx::crypto::CrossSigningKeys> master_keys;
//! A map from user ID, to information about user_signing_keys.
std::map<std::string, mtx::crypto::CrossSigningKeys> user_signing_keys;
//! A map from user ID, to information about self_signing_keys.
std::map<std::string, mtx::crypto::CrossSigningKeys> self_signing_keys;
};
void
to_json(nlohmann::json &obj, const QueryKeys &response);
void
from_json(const nlohmann::json &obj, QueryKeys &response);
//! Request for `POST /_matrix/client/r0/keys/upload`.
struct KeySignaturesUpload
{
//! Errors returned during upload.
std::map<std::string, std::map<std::string, mtx::errors::LightweightError>> errors;
};
void
from_json(const nlohmann::json &obj, KeySignaturesUpload &response);
//! Response from the `POST /_matrix/client/r0/keys/claim` endpoint.
struct ClaimKeys
{
//! If any remote homeservers could not be reached, they are
//! recorded here. The names of the properties are the names
//! of the unreachable servers.
std::map<std::string, nlohmann::json> failures;
//! One-time keys for the queried devices. A map from user ID,
//! to a map from <algorithm>:<key_id> to the key object.
std::map<std::string, std::map<std::string, nlohmann::json>> one_time_keys;
};
void
from_json(const nlohmann::json &obj, ClaimKeys &response);
//! Response from the `GET /_matrix/client/r0/keys/changes` endpoint.
struct KeyChanges
{
//! The Matrix User IDs of all users who updated their device identity keys.
std::vector<std::string> changed;
//! The Matrix User IDs of all users who may have left all the end-to-end
//! encrypted rooms they previously shared with the user.
std::vector<std::string> left;
};
void
from_json(const nlohmann::json &obj, KeyChanges &response);
//! KeysBackup related responses.
namespace backup {
//! Encrypted session data using the m.megolm_backup.v1.curve25519-aes-sha2 algorithm
struct EncryptedSessionData
{
//! Generate an ephemeral curve25519 key, and perform an ECDH with the ephemeral key and the
//! backup's public key to generate a shared secret. The public half of the ephemeral key,
//! encoded using unpadded base64, becomes the ephemeral property
std::string ephemeral;
//! Stringify the JSON object, and encrypt it using AES-CBC-256 with PKCS#7 padding. This
//! encrypted data, encoded using unpadded base64, becomes the ciphertext property of the
//! session_data.
std::string ciphertext;
//! Pass the raw encrypted data (prior to base64 encoding) through HMAC-SHA-256 using the
//! MAC key generated above. The first 8 bytes of the resulting MAC are base64-encoded, and
//! become the mac property of the session_data.
std::string mac;
};
void
from_json(const nlohmann::json &obj, EncryptedSessionData &response);
void
to_json(nlohmann::json &obj, const EncryptedSessionData &response);
//! Responses from the `GET /_matrix/client/r0/room_keys/keys/{room_id}/{session_id}` endpoint
struct SessionBackup
{
//! Required. The index of the first message in the session that the key can decrypt.
int64_t first_message_index;
//! Required. The number of times this key has been forwarded via key-sharing between
//! devices.
int64_t forwarded_count;
//! Required. Whether the device backing up the key verified the device that the key is
//! from.
bool is_verified;
//! Required. Algorithm-dependent data. See the documentation for the backup algorithms in
//! Server-side key backups for more information on the expected format of the data.
EncryptedSessionData session_data;
};
void
from_json(const nlohmann::json &obj, SessionBackup &response);
void
to_json(nlohmann::json &obj, const SessionBackup &response);
//! Responses from the `GET /_matrix/client/r0/room_keys/keys/{room_id}` endpoint
struct RoomKeysBackup
{
//! map of session id to the individual sessions
std::map<std::string, SessionBackup> sessions;
};
void
from_json(const nlohmann::json &obj, RoomKeysBackup &response);
void
to_json(nlohmann::json &obj, const RoomKeysBackup &response);
//! Responses from the `GET /_matrix/client/r0/room_keys/keys` endpoint
struct KeysBackup
{
//! map of room id to map of session ids to backups of individual sessions
std::map<std::string, RoomKeysBackup> rooms;
};
void
from_json(const nlohmann::json &obj, KeysBackup &response);
void
to_json(nlohmann::json &obj, const KeysBackup &response);
constexpr const char *megolm_backup_v1 = "m.megolm_backup.v1.curve25519-aes-sha2";
//! Responses from the `GET /_matrix/client/r0/room_keys/version` endpoint
struct BackupVersion
{
//! Required. The algorithm used for storing backups. Must be
//! 'm.megolm_backup.v1.curve25519-aes-sha2'.
std::string algorithm;
//! Required. Algorithm-dependent data. See the documentation for the backup algorithms in
//! Server-side key backups for more information on the expected format of the data.
std::string auth_data;
//! Required. The number of keys stored in the backup.
int64_t count;
//! Required. An opaque string representing stored keys in the backup. Clients can
//! compare it with the etag value they received in the request of their last key storage
//! request. If not equal, another client has modified the backup
std::string etag;
//! Required. The backup version
std::string version;
};
void
from_json(const nlohmann::json &obj, BackupVersion &response);
void
to_json(nlohmann::json &obj, const BackupVersion &response);
//! The SessionData stored in the KeysBackup.
struct SessionData
{
//! Required. The end-to-end message encryption algorithm that the key is
// for. Must be m.megolm.v1.aes-sha2.
std::string algorithm;
// Required. Chain of Curve25519 keys through which this
// session was forwarded, via m.forwarded_room_key events.
std::vector<std::string> forwarding_curve25519_key_chain;
// Required. Unpadded base64-encoded device curve25519 key.
std::string sender_key;
// Required. A map from algorithm name (ed25519) to the identity
// key for the sending device.
std::map<std::string, std::string> sender_claimed_keys;
// Required. Unpadded base64-encoded session key in session-sharing format.
std::string session_key;
};
void
to_json(nlohmann::json &obj, const SessionData &desc);
void
from_json(const nlohmann::json &obj, SessionData &desc);
}
} // namespace responses
} // namespace mtx
| 37.518868
| 96
| 0.729444
|
govynnus
|
48441cd0555c543fe874f8f754f553d2736764db
| 1,290
|
hpp
|
C++
|
src/lib/storage/vector_compression/bitpacking/bitpacking_vector.hpp
|
mrcl-tst/hyrise
|
eec50b39de9f530b0a1732ceb5822b7222f3fe17
|
[
"MIT"
] | 583
|
2015-01-10T00:55:32.000Z
|
2022-03-25T12:24:30.000Z
|
src/lib/storage/vector_compression/bitpacking/bitpacking_vector.hpp
|
mrcl-tst/hyrise
|
eec50b39de9f530b0a1732ceb5822b7222f3fe17
|
[
"MIT"
] | 1,573
|
2015-01-07T15:47:22.000Z
|
2022-03-31T11:48:03.000Z
|
src/lib/storage/vector_compression/bitpacking/bitpacking_vector.hpp
|
mrcl-tst/hyrise
|
eec50b39de9f530b0a1732ceb5822b7222f3fe17
|
[
"MIT"
] | 145
|
2015-03-09T16:26:07.000Z
|
2022-02-15T12:53:23.000Z
|
#pragma once
#include "bitpacking_decompressor.hpp"
#include "bitpacking_iterator.hpp"
#include "bitpacking_vector_type.hpp"
#include "compact_vector.hpp"
#include "storage/vector_compression/base_compressed_vector.hpp"
namespace opossum {
/**
* @brief Bit-packed vector with fixed bit length
*
* Bit-packed Null Suppression.
* All values of the sequences are compressed with the same bit length, which is determined by the bits required to
* represent the maximum value of the sequence. The decoding runtime is only marginally slower than
* FixedWidthIntegerVector but the compression rate of BitPacking is significantly better.
*
*/
class BitPackingVector : public CompressedVector<BitPackingVector> {
public:
explicit BitPackingVector(pmr_compact_vector data);
const pmr_compact_vector& data() const;
size_t on_size() const;
size_t on_data_size() const;
std::unique_ptr<BaseVectorDecompressor> on_create_base_decompressor() const;
BitPackingDecompressor on_create_decompressor() const;
BitPackingIterator on_begin() const;
BitPackingIterator on_end() const;
std::unique_ptr<const BaseCompressedVector> on_copy_using_allocator(const PolymorphicAllocator<size_t>& alloc) const;
private:
const pmr_compact_vector _data;
};
} // namespace opossum
| 30.714286
| 119
| 0.795349
|
mrcl-tst
|
484652da790a2aeceeec1f214398ed833e61f004
| 4,716
|
cpp
|
C++
|
tests/minimongo.cpp
|
almightycouch/meteorpp
|
e8af587c88902fb79820317a6d579ace43d883b1
|
[
"MIT"
] | 24
|
2015-10-25T11:34:02.000Z
|
2018-09-10T17:10:52.000Z
|
tests/minimongo.cpp
|
almightycouch/meteorpp
|
e8af587c88902fb79820317a6d579ace43d883b1
|
[
"MIT"
] | 3
|
2018-08-05T14:01:43.000Z
|
2019-02-15T14:44:42.000Z
|
tests/minimongo.cpp
|
almightycouch/meteorpp
|
e8af587c88902fb79820317a6d579ace43d883b1
|
[
"MIT"
] | 9
|
2016-05-09T13:56:58.000Z
|
2021-11-01T23:53:38.000Z
|
#include <set>
#include <meteorpp/collection.hpp>
#include <boost/test/unit_test.hpp>
struct fixture {
fixture() : coll(std::make_shared<meteorpp::collection>("test")) {}
std::shared_ptr<meteorpp::collection> coll;
};
BOOST_AUTO_TEST_CASE(create_collection)
{
BOOST_CHECK_NO_THROW(std::make_shared<meteorpp::collection>("test"));
}
BOOST_AUTO_TEST_CASE(create_invalid_collection)
{
BOOST_CHECK_THROW(std::make_shared<meteorpp::collection>(""), meteorpp::ejdb_exception);
}
BOOST_FIXTURE_TEST_CASE(insert_with_oid, fixture)
{
std::string const oid = "d776bb695e5447997999b1fd";
BOOST_CHECK_EQUAL(coll->insert({{ "_id", oid }, { "foo", "bar" }}), oid);
}
BOOST_FIXTURE_TEST_CASE(insert_with_invalid_oid, fixture)
{
std::string const oid = "0xe5505";
BOOST_CHECK_THROW(coll->insert({{ "_id", oid }, { "foo", "bar" }}), meteorpp::ejdb_exception);
}
BOOST_FIXTURE_TEST_CASE(insert_count, fixture)
{
for(auto i = 1; i <= 10; ++i) {
coll->insert({{ "foo", "bar" }});
BOOST_CHECK_EQUAL(coll->count(), i);
}
}
BOOST_FIXTURE_TEST_CASE(insert_count_with_query, fixture)
{
coll->insert({{ "foo", "bar"}});
coll->insert({{ "foo", "baz"}});
coll->insert({{ "foo", "bar"}, { "bar", "foo" }});
coll->insert({{ "foo", "baz"}, { "bar", "foo" }});
BOOST_CHECK_EQUAL(coll->count({{ "foo", "bar" }}), 2);
BOOST_CHECK_EQUAL(coll->count({{ "foo", "baz" }}), 2);
BOOST_CHECK_EQUAL(coll->count({{ "bar", "foo" }}), 2);
BOOST_CHECK_EQUAL(coll->count({{ "foo", "bar" }, { "bar", "foo" }}), 1);
BOOST_CHECK_EQUAL(coll->count({{ "$or", { {{ "foo", "bar"}}, {{ "bar", "foo" }} } }}), 3);
}
BOOST_FIXTURE_TEST_CASE(insert_find_one, fixture)
{
nlohmann::json::object_t doc = {{ "foo", "bar" }};
doc.insert(std::make_pair("_id", coll->insert(doc)));
BOOST_CHECK_EQUAL(coll->find_one(), doc);
}
BOOST_FIXTURE_TEST_CASE(insert_find_multi, fixture)
{
nlohmann::json::object_t doc1 = {{ "foo", "bar" }};
doc1.insert(std::make_pair("_id", coll->insert(doc1)));
nlohmann::json::object_t doc2 = {{ "foo", "baz" }};
doc2.insert(std::make_pair("_id", coll->insert(doc2)));
auto const excepted = { doc1, doc2 };
BOOST_CHECK_EQUAL(coll->find(), excepted);
}
BOOST_FIXTURE_TEST_CASE(insert_update_one, fixture)
{
nlohmann::json::object_t doc = {{ "foo", "bar" }};
doc.insert(std::make_pair("_id", coll->insert(doc)));
auto const it = coll->update(doc, {{ "$set", {{ "foo", "baz" }}}});
BOOST_CHECK_EQUAL(it, 1);
doc["foo"] = "baz";
BOOST_CHECK_EQUAL(coll->find_one(), doc);
}
BOOST_FIXTURE_TEST_CASE(insert_update_multi, fixture)
{
nlohmann::json::object_t doc1 = {{ "foo", "bar" }};
doc1.insert(std::make_pair("_id", coll->insert(doc1)));
nlohmann::json::object_t doc2 = {{ "foo", "baz" }};
doc2.insert(std::make_pair("_id", coll->insert(doc2)));
auto const it = coll->update({}, {{ "$set", {{ "bar", "foo" }}}});
BOOST_CHECK_EQUAL(it, 2);
doc1["bar"] = "foo";
doc2["bar"] = "foo";
auto const excepted = { doc1, doc2 };
BOOST_CHECK_EQUAL(coll->find(), excepted);
}
BOOST_FIXTURE_TEST_CASE(insert_multi_update_one, fixture)
{
nlohmann::json::object_t doc1 = {{ "foo", "bar" }};
doc1.insert(std::make_pair("_id", coll->insert(doc1)));
nlohmann::json::object_t doc2 = {{ "foo", "baz" }};
doc2.insert(std::make_pair("_id", coll->insert(doc2)));
auto const it = coll->update(doc1, {{ "$set", {{ "bar", "foo" }}}});
BOOST_CHECK_EQUAL(it, 1);
doc1["bar"] = "foo";
auto const result_vect = coll->find();
std::set<nlohmann::json::object_t> const result_set(result_vect.begin(), result_vect.end());
std::set<nlohmann::json::object_t> const excepted = { doc1, doc2 };
BOOST_CHECK_EQUAL(result_set, excepted);
}
BOOST_FIXTURE_TEST_CASE(insert_remove_one, fixture)
{
auto const id = coll->insert({{ "foo", "bar" }});
auto const it = coll->remove({{ "_id", id }});
BOOST_CHECK_EQUAL(it, 1);
BOOST_CHECK(coll->find_one().empty());
}
BOOST_FIXTURE_TEST_CASE(insert_remove_multi, fixture)
{
coll->insert({{ "foo", "bar" }});
coll->insert({{ "foo", "baz" }});
auto const it = coll->remove({});
BOOST_CHECK_EQUAL(it, 2);
BOOST_CHECK(coll->find_one().empty());
}
BOOST_FIXTURE_TEST_CASE(insert_multi_remove_one, fixture)
{
nlohmann::json::object_t doc1 = {{ "foo", "bar" }};
doc1.insert(std::make_pair("_id", coll->insert(doc1)));
nlohmann::json::object_t doc2 = {{ "foo", "baz" }};
doc2.insert(std::make_pair("_id", coll->insert(doc2)));
auto const it = coll->remove(doc1);
BOOST_CHECK_EQUAL(it, 1);
BOOST_CHECK_EQUAL(coll->find_one(), doc2);
}
| 30.425806
| 98
| 0.626166
|
almightycouch
|
48499516798e6e901a3953c47941556f8d7ab2c8
| 6,269
|
hpp
|
C++
|
tests/unit/coherence/run/xml/XmlTokenTest.hpp
|
chpatel3/coherence-cpp-extend-client
|
4ea5267eae32064dff1e73339aa3fbc9347ef0f6
|
[
"UPL-1.0",
"Apache-2.0"
] | 6
|
2020-07-01T21:38:30.000Z
|
2021-11-03T01:35:11.000Z
|
tests/unit/coherence/run/xml/XmlTokenTest.hpp
|
chpatel3/coherence-cpp-extend-client
|
4ea5267eae32064dff1e73339aa3fbc9347ef0f6
|
[
"UPL-1.0",
"Apache-2.0"
] | 1
|
2020-07-24T17:29:22.000Z
|
2020-07-24T18:29:04.000Z
|
tests/unit/coherence/run/xml/XmlTokenTest.hpp
|
chpatel3/coherence-cpp-extend-client
|
4ea5267eae32064dff1e73339aa3fbc9347ef0f6
|
[
"UPL-1.0",
"Apache-2.0"
] | 6
|
2020-07-10T18:40:58.000Z
|
2022-02-18T01:23:40.000Z
|
/*
* Copyright (c) 2000, 2020, Oracle and/or its affiliates.
*
* Licensed under the Universal Permissive License v 1.0 as shown at
* http://oss.oracle.com/licenses/upl.
*/
#include "cxxtest/TestSuite.h"
#include "coherence/lang.ns"
#include "private/coherence/run/xml/XmlToken.hpp"
#include <stdio.h>
using namespace coherence::lang;
using namespace coherence::run::xml;
using namespace std;
/**
* Test Suite for the XmlToken object.
*/
class XmlTokenSuite : public CxxTest::TestSuite
{
public:
/**
* Test getCategory
*/
void testGetCategory()
{
XmlToken::Handle token = XmlToken::create(XmlToken::cat_name, XmlToken::subcat_lit_pi, XmlToken::name, String::create("Value"), String::create("Text"));
TS_ASSERT( token->getCategory()== XmlToken::cat_name);
token = XmlToken::create(token, 0, 1, 2);
TS_ASSERT( token->getCategory()== XmlToken::cat_name);
token = XmlToken::create(XmlToken::cat_literal, XmlToken::subcat_lit_pi, XmlToken::name, String::create("Value"), String::create("Text"), 0, 1, 2);
TS_ASSERT( token->getCategory()== XmlToken::cat_literal);
}
/**
* Test getSubCategory
*/
void testGetSubCategory()
{
XmlToken::Handle token = XmlToken::create(XmlToken::cat_name, XmlToken::subcat_lit_pi, XmlToken::name, String::create("Value"), String::create("Text"));
TS_ASSERT( token->getSubCategory()== XmlToken::subcat_lit_pi);
token = XmlToken::create(token, 0, 1, 2);
TS_ASSERT( token->getSubCategory()== XmlToken::subcat_lit_pi);
token = XmlToken::create(XmlToken::cat_literal, XmlToken::subcat_lit_comment, XmlToken::name, String::create("Value"), String::create("Text"), 0, 1, 2);
TS_ASSERT( token->getSubCategory()== XmlToken::subcat_lit_comment);
}
/**
* Test getId
*/
void testGetId()
{
XmlToken::Handle token = XmlToken::create(XmlToken::cat_name, XmlToken::subcat_lit_pi, XmlToken::name, String::create("Value"), String::create("Text"));
TS_ASSERT( token->getID()== XmlToken::name);
token = XmlToken::create(token, 0, 1, 2);
TS_ASSERT( token->getID()== XmlToken::name);
token = XmlToken::create(XmlToken::cat_literal, XmlToken::subcat_lit_comment, XmlToken::literal, String::create("Value"), String::create("Text"), 0, 1, 2);
TS_ASSERT( token->getID()== XmlToken::literal);
}
/**
* Test getValue
*/
void testGetValue()
{
XmlToken::Handle token = XmlToken::create(XmlToken::cat_name, XmlToken::subcat_lit_pi, XmlToken::name, String::create("Value"), String::create("Text"));
TS_ASSERT( String::create("Value")->equals(token->getValue()));
token = XmlToken::create(token, 0, 1, 2);
TS_ASSERT( String::create("Value")->equals(token->getValue()));
token = XmlToken::create(XmlToken::cat_literal, XmlToken::subcat_lit_comment, XmlToken::literal, String::create("Another Value"), String::create("Text"), 0, 1, 2);
TS_ASSERT( String::create("Another Value")->equals(token->getValue()) );
}
/**
* Test getText
*/
void testGetText()
{
XmlToken::Handle token = XmlToken::create(XmlToken::cat_name, XmlToken::subcat_lit_pi, XmlToken::name, String::create("Value"), String::create("Text"));
TS_ASSERT( String::create("Text")->equals(token->getText()));
token = XmlToken::create(token, 0, 1, 2);
TS_ASSERT( String::create("Text")->equals(token->getText()));
token = XmlToken::create(XmlToken::cat_literal, XmlToken::subcat_lit_comment, XmlToken::literal, String::create("Another Value"), String::create("More Text"), 0, 1, 2);
TS_ASSERT( String::create("More Text")->equals(token->getText()) );
}
/**
* Test getLine
*/
void testGetLine()
{
XmlToken::Handle token = XmlToken::create(XmlToken::cat_name, XmlToken::subcat_lit_pi, XmlToken::name, String::create("Value"), String::create("Text"));
TS_ASSERT( token->getLine()== 0);
token = XmlToken::create(token, 0, 1, 2);
TS_ASSERT( token->getLine()== 0);
token = XmlToken::create(XmlToken::cat_literal, XmlToken::subcat_lit_comment, XmlToken::literal, String::create("Another Value"), String::create("More Text"), 99, 1, 2);
TS_ASSERT( token->getLine()== 99);
}
/**
* Test getOffset
*/
void testGetOffset()
{
XmlToken::Handle token = XmlToken::create(XmlToken::cat_name, XmlToken::subcat_lit_pi, XmlToken::name, String::create("Value"), String::create("Text"));
TS_ASSERT( token->getOffset()== 0);
token = XmlToken::create(token, 0, 1, 2);
TS_ASSERT( token->getOffset()== 1);
token = XmlToken::create(XmlToken::cat_literal, XmlToken::subcat_lit_comment, XmlToken::literal, String::create("Another Value"), String::create("More Text"), 0, 99, 2);
TS_ASSERT( token->getOffset()== 99);
}
/**
* Test getLength
*/
void testGetLength()
{
XmlToken::Handle token = XmlToken::create(XmlToken::cat_name, XmlToken::subcat_lit_pi, XmlToken::name, String::create("Value"), String::create("Text"));
TS_ASSERT( token->getLength()== 0);
token = XmlToken::create(token, 0, 1, 2);
TS_ASSERT( token->getLength()== 2);
token = XmlToken::create(XmlToken::cat_literal, XmlToken::subcat_lit_comment, XmlToken::literal, String::create("Another Value"), String::create("More Text"), 0, 1, 99);
TS_ASSERT( token->getLength()== 99);
}
/**
* Test adjust
*/
void testAdjust() {
XmlToken::Handle token = XmlToken::create(XmlToken::cat_literal, XmlToken::subcat_lit_comment, XmlToken::literal, String::create("Another Value"), String::create("More Text"), 0, 1, 99);
token->adjust( 10, 10 );
TS_ASSERT( token->getLine()== 10);
TS_ASSERT( token->getOffset()== 11);
token->adjust( -2, -2 );
TS_ASSERT( token->getLine()== 8);
TS_ASSERT( token->getOffset()== 9);
token->adjust( -10, -10 );
TS_ASSERT( token->getLine()== 0);
TS_ASSERT( token->getOffset()== 0);
}
};
| 36.236994
| 194
| 0.624502
|
chpatel3
|
4849f31b0b403e5bcc426ebb76afa2f6d6cdfd21
| 1,980
|
cpp
|
C++
|
Stocks/UrlDownloader.cpp
|
caicaiking/AbamaAnalysis
|
d3d370e59c7049be36e06da61e1a315ba58d049d
|
[
"MIT"
] | null | null | null |
Stocks/UrlDownloader.cpp
|
caicaiking/AbamaAnalysis
|
d3d370e59c7049be36e06da61e1a315ba58d049d
|
[
"MIT"
] | null | null | null |
Stocks/UrlDownloader.cpp
|
caicaiking/AbamaAnalysis
|
d3d370e59c7049be36e06da61e1a315ba58d049d
|
[
"MIT"
] | null | null | null |
#include "UrlDownloader.h"
#include <QNetworkReply>
namespace
{
inline int _calculateProgress(qint64 bytesReceived, qint64 bytesTotal)
{
if (!bytesTotal)
return 0;
if (bytesTotal == -1)
return -1;
return (bytesReceived * 100) / bytesTotal;
}
}
////////////////////////////////////////////////////////////////////////////////
UrlDownloader::UrlDownloader(int taskId, const QUrl &url, QNetworkAccessManager &nam, QObject *parent /*= nullptr*/)
: QObject(parent)
, _taskId(taskId)
, _url(url)
, _nam(nam)
, _reply(nullptr)
{ }
int UrlDownloader::taskId() const
{
return _taskId;
}
void UrlDownloader::start()
{
_reply = _nam.get(QNetworkRequest(_url));
connect(_reply, SIGNAL(downloadProgress(qint64,qint64)),
SLOT(onDownloadProgress(qint64,qint64)));
connect(_reply, SIGNAL(readyRead()),
SLOT(onReadyRead()));
connect(_reply, SIGNAL(finished()),
SLOT(onFinished()));
}
void UrlDownloader::stop()
{
if (!_reply)
return;
_reply->disconnect();
_reply->close();
_reply->deleteLater();
_reply = nullptr;
}
////////////////////////////////////////////////////////////////////////////////
void UrlDownloader::onDownloadProgress(qint64 bytesReceived, qint64 bytesTotal)
{
emit taskProgress(_taskId, _calculateProgress(bytesReceived, bytesTotal));
}
void UrlDownloader::onReadyRead()
{
emit taskData(_taskId, _reply->readAll());
}
void UrlDownloader::onFinished()
{
QNetworkReply::NetworkError errorCode = _reply->error();
switch(errorCode)
{
case QNetworkReply::NoError:
emit taskProgress(_taskId, 100);
emit taskComplete(_taskId);
break;
default:
emit taskError(_taskId, _reply->errorString());
break;
}
_reply->disconnect();
_reply->deleteLater();
_reply = nullptr;
emit taskFinished(this);
}
| 22
| 116
| 0.581818
|
caicaiking
|
484c7085cea5c8a7255c3081659fbb1693c448f5
| 5,739
|
cpp
|
C++
|
src/main.cpp
|
attaoveisi/pseudo_particle_filter
|
0bcb66b92661c0cd8fdf12db5a57d6f3df1a7940
|
[
"MIT"
] | 1
|
2021-01-10T10:52:13.000Z
|
2021-01-10T10:52:13.000Z
|
src/main.cpp
|
attaoveisi/pseudo_particle_filter
|
0bcb66b92661c0cd8fdf12db5a57d6f3df1a7940
|
[
"MIT"
] | null | null | null |
src/main.cpp
|
attaoveisi/pseudo_particle_filter
|
0bcb66b92661c0cd8fdf12db5a57d6f3df1a7940
|
[
"MIT"
] | null | null | null |
#include "Base.h"
#include "Robot.h"
#include "Map.h"
#include <matplot/matplot.h>
void visualization(int n, Robot robot, int step, std::vector<Robot> p, std::vector<Robot> pr, int num_landmarks)
{
//Draw the robot, landmarks, particles and resampled particles on a graph
matplot::figure(1);
//Graph Format
matplot::title("MCL, step " + std::to_string(step));
matplot::xlim({0.0, 100.0});
matplot::ylim({0.0, 100.0});
//Draw particles in green
for (int i = 0; i < n; i++) {
matplot::hold(matplot::on);
matplot::plot({ p[i].x }, { p[i].y }, "go");
}
matplot::hold(matplot::on);
//Draw resampled particles in yellow
for (int i = 0; i < n; i++) {
matplot::hold(matplot::on);
matplot::plot({ pr[i].x }, { pr[i].y }, "yo");
}
matplot::hold(matplot::on);
//Draw landmarks in red
for (int i = 0; i < num_landmarks; i++) {
matplot::hold(matplot::on);
matplot::plot({ robot.landmarks[i][0] }, { robot.landmarks[i][1] }, "ro");
}
//Draw robot position in blue
matplot::hold(matplot::on);
matplot::plot({ robot.x }, { robot.y }, "bo");
//Save the image and close the plot
matplot::show();
std::string fig_name = "./Images/Step" + std::to_string(step) + ".jpg";
std::cout << fig_name << " is saved." <<std::endl;
matplot::save(fig_name);
}
int main()
{
Base base;
// Landmarks
Map map;
// Map size in meters
double map_size = 100.0;
map.get_world_size(map_size);
int num_landmarks = 8;
std::vector<std::vector<double>> landmarks { { 20.0, 20.0 },
{ 20.0, 80.0 },
{ 20.0, 50.0 },
{ 50.0, 20.0 },
{ 50.0, 80.0 },
{ 80.0, 80.0 },
{ 80.0, 20.0 },
{ 80.0, 50.0 } };
for (int i = 0; i < num_landmarks; i++){
std::cout << landmarks[i][0] << "\t" << landmarks[i][1] << std::endl;
}
map.get_landmarks(landmarks, num_landmarks);
map.print_map();
//Initialize myrobot object and Initialize a measurment vector
Robot myrobot;
myrobot.get_world_size(map);
myrobot.get_landmarks(map);
myrobot.randomized_position(map);
//myrobot.set(30.0, 50.0, M_PI / 2.0);
myrobot.print_robot();
// Measurement vector
std::vector<double> z(num_landmarks);
std::vector<double> pz(num_landmarks);
//Iterating 50 times over the set of particles
int steps = 50;
// Create a set of particles
int n = 1000;
std::vector<Robot> p(n);
std::vector<Robot> p_temp(n);
std::vector<Robot> p3(n);
//std::cout << p[0].sense_noise << std::endl;
for (int i = 0; i < n; i++) {
p[i].get_world_size(map);
p[i].get_landmarks(map);
p[i].randomized_position(map);
p3[i].get_world_size(map);
p3[i].get_landmarks(map);
p3[i].randomized_position(map);
p[i].set_noise(0.05, 0.05, 5.0);
//std::cout << p[i].show_pose() << std::endl;
}
for (int t = 0; t < steps; t++) {
//Move the robot and sense the environment afterwards
myrobot.move(0.1, 5.0);
z = myrobot.sense();
//std::cout << z[0] << "\t" << z[1] << "\t" << z[2] << "\t" << z[3] << "\t" << z[4] << "\t" << z[5] << "\t" << z[6] << "\t" << z[7] << std::endl;
// Simulate a robot motion for each of these particles
for (int i = 0; i < n; i++) {
p_temp[i] = p[i];
p_temp[i].move(0.1, 5.0);
p[i] = p_temp[i];
//std::cout << p[i].show_pose() << std::endl;
}
//std::cout << p[0].show_pose() << std::endl;
//Generate particle weights depending on robot's measurement
std::vector<double> w(n);
for (int i = 0; i < n; i++) {
pz = p[i].sense();
w[i] = p[i].measurement_prob(z);
//cout << w[i] << endl;
}
//Resample the particles with a sample probability proportional to the importance weight
int index = base.gen_real_random() * n;
//cout << index << endl;
double beta = 0.0;
double mw = base.max(w, n);
//cout << mw;
for (int i = 0; i < n; i++) {
beta += base.gen_real_random() * 2.0 * mw;
while (beta > w[index]) {
beta -= w[index];
index = base.mod((index + 1), n);
}
p3[i] = p[index];
}
for (int k=0; k < n; k++) {
p[k] = p3[k];
//cout << p[k].show_pose() << endl;
}
//#### DON'T MODIFY ANYTHING ABOVE HERE! ENTER CODE BELOW ####
//Evaluate the error by priting it in this form:
// cout << "Step = " << t << ", Evaluation = " << ErrorValue << endl;
double sum = 0.0;
for (int i = 0; i < n; i++) {
//the second part is because of world's cyclicity
double dx = base.mod((p[i].x - myrobot.x + (map_size / 2.0)), map_size) - (map_size / 2.0);
double dy = base.mod((p[i].y - myrobot.y + (map_size / 2.0)), map_size) - (map_size / 2.0);
double err = sqrt(pow(dx, 2) + pow(dy, 2));
sum += err;
}
sum = sum / n;
std::cout << "Step = " << t << ", Evaluation = " << sum << std::endl;
//Graph the position of the robot and the particles at each step
visualization(n, myrobot, t, p_temp, p3, num_landmarks);
} //End of Steps loop
return 0;
}
| 33.758824
| 153
| 0.488935
|
attaoveisi
|
484ffbfe261670a5eea4eeaba9d84f2fc5848b26
| 1,544
|
cpp
|
C++
|
sg/scene/transfer_function/Sequential.cpp
|
ebachard/ospray_studio
|
78928c93b482f9f95aa300c8f58c728dadedbe2f
|
[
"Apache-2.0"
] | 52
|
2018-10-09T23:56:32.000Z
|
2022-03-25T09:27:40.000Z
|
sg/scene/transfer_function/Sequential.cpp
|
ebachard/ospray_studio
|
78928c93b482f9f95aa300c8f58c728dadedbe2f
|
[
"Apache-2.0"
] | 11
|
2018-11-19T18:51:47.000Z
|
2022-03-28T14:03:57.000Z
|
sg/scene/transfer_function/Sequential.cpp
|
ebachard/ospray_studio
|
78928c93b482f9f95aa300c8f58c728dadedbe2f
|
[
"Apache-2.0"
] | 8
|
2019-02-10T00:16:24.000Z
|
2022-02-17T19:50:15.000Z
|
// Copyright 2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#include "TransferFunction.h"
namespace ospray {
namespace sg {
// Turbo /////////////////////////////////////////////////////////////////////
struct OSPSG_INTERFACE Turbo : public TransferFunction
{
Turbo();
virtual ~Turbo() override = default;
};
OSP_REGISTER_SG_NODE_NAME(Turbo, transfer_function_turbo);
Turbo::Turbo() : TransferFunction("piecewiseLinear")
{
colors.clear();
colors.emplace_back(0.190, 0.072, 0.232);
colors.emplace_back(0.276, 0.421, 0.891);
colors.emplace_back(0.158, 0.736, 0.923);
colors.emplace_back(0.197, 0.949, 0.595);
colors.emplace_back(0.644, 0.990, 0.234);
colors.emplace_back(0.933, 0.812, 0.227);
colors.emplace_back(0.984, 0.493, 0.128);
colors.emplace_back(0.816, 0.185, 0.018);
colors.emplace_back(0.480, 0.016, 0.011);
initOpacities();
createChildData("color", colors);
createChildData("opacity", opacities);
}
// Grayscale /////////////////////////////////////////////////////////////////
struct OSPSG_INTERFACE Grayscale : public TransferFunction
{
Grayscale();
virtual ~Grayscale() override = default;
};
OSP_REGISTER_SG_NODE_NAME(Grayscale, transfer_function_grayscale);
Grayscale::Grayscale() : TransferFunction("piecewiseLinear")
{
colors.clear();
colors.emplace_back(0.000, 0.000, 0.000);
colors.emplace_back(1.000, 1.000, 1.000);
initOpacities();
createChildData("color", colors);
createChildData("opacity", opacities);
}
} // namespace sg
} // namespace ospray
| 24.903226
| 78
| 0.658031
|
ebachard
|
48565b4701e322be364081f515a1ecdd9a93f66f
| 14,757
|
cpp
|
C++
|
src/main.cpp
|
JamesBremner/pack2
|
b6156f5621206d9836a8d52172641a94fa52df13
|
[
"BSD-2-Clause"
] | 2
|
2020-03-17T00:46:50.000Z
|
2020-04-13T21:22:10.000Z
|
src/main.cpp
|
JamesBremner/pack2
|
b6156f5621206d9836a8d52172641a94fa52df13
|
[
"BSD-2-Clause"
] | null | null | null |
src/main.cpp
|
JamesBremner/pack2
|
b6156f5621206d9836a8d52172641a94fa52df13
|
[
"BSD-2-Clause"
] | null | null | null |
#include <iostream>
#include <sstream>
#include <memory>
#include <vector>
#include <algorithm>
#include <cutest.h>
using namespace std;
#include "pack2.h"
TEST( CutList )
{
pack2::cPackEngine E;
E.add( pack2::bin_t( new pack2::cBin( "Bin1", 100, 100 )) );
E.addItem( "Item1", 20, 20 );
E.addItem( "Item2", 20, 20 );
Pack( E );
auto L = pack2::CutList( E );
// for( auto& c : L )
// {
// for( int v : c )
// std::cout << v << ", ";
// std::cout << "\n";
// }
CHECK_EQUAL( 3, L.size() );
CHECK_EQUAL( 20, L[2][1] );
CHECK_EQUAL( 0, L[2][2] );
CHECK_EQUAL( 20, L[2][3] );
CHECK_EQUAL( 40, L[2][4] );
}
TEST( CutListJoin )
{
pack2::cPackEngine E;
E.add( pack2::bin_t( new pack2::cBin( "CutListJoin", 1000, 1000 )) );
E.addItem( "Item1", 500, 200 );
E.addItem( "Item2", 500, 200 );
E.addItem( "Item3", 200, 20 );
E.addItem( "Item4", 600, 20 );
Pack( E );
auto L = pack2::CutList( E );
// for( auto& c : L )
// {
// for( int v : c )
// std::cout << v << ", ";
// std::cout << "\n";
// }
CHECK_EQUAL( 6, L.size() );
}
TEST( spin )
{
pack2::cPackEngine E;
auto b = pack2::bin_t( new pack2::cBin( "Bin1", 20, 100 ));
E.add( b );
E.addItem( "Item1", 100, 10 );
E.addItem( "Item2", 100, 10 );
Pack( E );
CHECK_EQUAL( 0, BinCount( E ) );
E.clear();
b = pack2::bin_t( new pack2::cBin( "Bin1", 20, 100 ));
E.add( b );
E.addItem( "Item1", 100, 10 );
E.addItem( "Item2", 100, 10 );
E.items()[0]->spinEnable();
E.items()[1]->spinEnable();
Pack( E );
CHECK_EQUAL( 1, BinCount( E ) );
}
TEST( CreateRemainingSpaces )
{
pack2::cPackEngine E;
pack2::bin_t b = pack2::bin_t( new pack2::cBin( "Bin1", 100, 100 ));
E.add( b );
pack2::item_t item = pack2::item_t( new pack2::cItem("i1",0,0));
item->sizX( 5 );
item->sizY( 10 );
CreateRemainingSpaces( E, b, item );
CHECK( pack2::cShape(5,0,95,100) == *(pack2::cShape*)Spaces(E,b)[0].get() );
CHECK( pack2::cShape(0,10,5,90) == *(pack2::cShape*)Spaces(E,b)[1].get() );
}
TEST( StrightThru )
{
pack2::cPackEngine E;
E.Algorithm().fThruCuts = true;
pack2::bin_t b = pack2::bin_t( new pack2::cBin( "Bin1", 100, 100 ));
b->copyEnable();
E.add( b );
E.addItem( "Item50by40", 50, 40 );
Pack( E );
CHECK_EQUAL( 1, BinCount( E ));
}
TEST( pack1 )
{
pack2::cPackEngine E;
pack2::bin_t b = pack2::bin_t( new pack2::cBin( "Bin2", 100, 100 ));
b->copyEnable();
E.add( b );
E.addItem( "Item50by40", 50, 40 );
E.addItem( "Item60by20", 60, 20 );
Pack( E );
CHECK_EQUAL( 1, BinCount( E ));
E.clear();
b = pack2::bin_t( new pack2::cBin( "Bin3", 100, 100 ));
E.add( b );
E.addItem( "Item90by80", 90, 80 );
E.addItem( "Item80by20", 80, 20 );
E.addItem( "Item5by100", 5, 100 );
Pack( E );
CHECK_EQUAL( 1, BinCount( E ));
}
TEST( subtract1 )
{
pack2::cShape s1( "1",800,750);
s1.locate( 1600,0 );
pack2::cShape s2( "2", 1100, 300 );
s2.locate( 1300, 700 );
CHECK( s1.isOverlap( s2 ) );
s1.subtract( s2 );
CHECK_EQUAL( 1600, s1.locX());
CHECK_EQUAL( 0, s1.locY());
CHECK_EQUAL( 800, s1.sizX() );
CHECK_EQUAL( 700, s1.sizY() );
}
TEST( subtract2 )
{
pack2::cShape s1( "1",1600,600);
s1.locate( 0,1000 );
pack2::cShape s2( "2", 1100, 300 );
s2.locate( 1300, 700 );
CHECK( s1.isOverlap( s2 ) );
s1.subtract( s2 );
CHECK_EQUAL( 0, s1.locX());
CHECK_EQUAL( 1000, s1.locY());
CHECK_EQUAL( 1300, s1.sizX() );
CHECK_EQUAL( 600, s1.sizY() );
}
TEST( subtract3 )
{
pack2::cShape s1( "1",200,200);
s1.locate( 1200,600 );
pack2::cShape s2( "2", 1100, 300 );
s2.locate( 1300, 700 );
CHECK( s1.isOverlap( s2 ) );
s1.subtract( s2 );
CHECK_EQUAL( 1200, s1.locX());
CHECK_EQUAL( 600, s1.locY());
CHECK_EQUAL( 100, s1.sizX() );
CHECK_EQUAL( 100, s1.sizY() );
}
TEST( tid11 )
{
pack2::cPackEngine thePackEngine;
pack2::bin_t b = pack2::bin_t( new pack2::cBin( "Bin1", 2400,1200 ));
b->copyEnable();
thePackEngine.add( b );
//thePackEngine.addItem( "621_1", 914,316 );
thePackEngine.addItem( "621_2", 1100,500 );
thePackEngine.addItem( "621_3", 1600,500 );
//thePackEngine.addItem( "621_4", 1600,250 );
thePackEngine.addItem( "621_5", 1200,250 );
Pack( thePackEngine );
}
TEST( SortBinsIntoIncreasingSize )
{
pack2::cPackEngine thePackEngine;
pack2::bin_t b;
b = pack2::bin_t( new pack2::cBin( "Bin1", 100, 100 ));
thePackEngine.add( b );
pack2::bin_t b2 = pack2::bin_t( new pack2::cBin( b ));
thePackEngine.add( b2 );
thePackEngine.add( pack2::bin_t( new pack2::cBin( b2, 50, 50, 3, 3 )));
thePackEngine.add( pack2::bin_t( new pack2::cBin( b, 50, 50, 10, 10 )));
thePackEngine.add( pack2::bin_t( new pack2::cBin( b, 60, 60, 5, 5 )));
SortBinsIntoIncreasingSize( thePackEngine );
// for( pack2::bin_t b : thePackEngine.bins() )
// std::cout << b->text();
CHECK_EQUAL( 5, thePackEngine.bins()[0]->sizX() );
CHECK_EQUAL( 10, thePackEngine.bins()[1]->sizX() );
CHECK_EQUAL( 3, thePackEngine.bins()[3]->sizX() );
}
/*
merge from BWPCENPLY16_GREY_21091HGL_cpy2 100 3174x5292 at 7484 6908
BWPCENPLY16_GREY_21091HGL_cpy2 99 7484x1824 at 0 10376
to BWPCENPLY16_GREY_21091HGL_cpy2 101 10658x1824 at 0 10376
BWPCENPLY16_GREY_21091HGL_cpy2 100 3174x3468 at 7484 6908
BWPCENPLY16_GREY_21091HGL_cpy2 99 7484x0 at 0 10376
*/
TEST( MergePairs8 )
{
pack2::cPackEngine thePackEngine;
pack2::bin_t b;
b = pack2::bin_t( new pack2::cBin( "Bin1", 24400,12200 ));
thePackEngine.add( b );
thePackEngine.add( pack2::bin_t( new pack2::cBin( b, 7484, 6908, 3174, 5292 )));
thePackEngine.add( pack2::bin_t( new pack2::cBin( b, 0, 10376, 7484, 1824 )));
MergePairs( thePackEngine, b );
// for( pack2::bin_t b : thePackEngine.bins() )
// std::cout << b->text();
}
TEST( MergePairs1 )
{
pack2::cPackEngine thePackEngine;
pack2::bin_t b;
// equal spaces adjacent left/right even
b = pack2::bin_t( new pack2::cBin( "Bin1", 100, 100 ));
thePackEngine.add( b );
thePackEngine.add( pack2::bin_t( new pack2::cBin( b, 50, 50, 20, 20 )));
thePackEngine.add( pack2::bin_t( new pack2::cBin( b, 30, 50, 20, 20 )));
MergePairs( thePackEngine, b );
// for( pack2::bin_t b : thePackEngine.bins() )
// std::cout << b->text();
CHECK_EQUAL( 2, (int)thePackEngine.bins().size() );
CHECK_EQUAL(30, thePackEngine.bins()[1]->locX());
CHECK_EQUAL(50, thePackEngine.bins()[1]->locY());
CHECK_EQUAL(40, thePackEngine.bins()[1]->sizX());
CHECK_EQUAL(20, thePackEngine.bins()[1]->sizY());
}
TEST( MergePairs2 )
{
pack2::cPackEngine thePackEngine;
pack2::bin_t b;
// equal spaces adjacent left/right left higher
b = pack2::bin_t( new pack2::cBin( "Bin1", 100, 100 ));
thePackEngine.add( b );
thePackEngine.add( pack2::bin_t( new pack2::cBin( b, 50, 50, 20, 20 )));
thePackEngine.add( pack2::bin_t( new pack2::cBin( b, 30, 49, 20, 20 )));
MergePairs( thePackEngine, b );
// for( pack2::bin_t b : thePackEngine.bins() )
// std::cout << b->text();
CHECK_EQUAL( 4, (int)thePackEngine.bins().size() );
CHECK_EQUAL(50, thePackEngine.bins()[1]->locX());
CHECK_EQUAL(69, thePackEngine.bins()[1]->locY());
CHECK_EQUAL(20, thePackEngine.bins()[1]->sizX());
CHECK_EQUAL( 1, thePackEngine.bins()[1]->sizY());
CHECK_EQUAL(30, thePackEngine.bins()[2]->locX());
CHECK_EQUAL(49, thePackEngine.bins()[2]->locY());
CHECK_EQUAL(20, thePackEngine.bins()[2]->sizX());
CHECK_EQUAL( 1, thePackEngine.bins()[2]->sizY());
CHECK_EQUAL(30, thePackEngine.bins()[3]->locX());
CHECK_EQUAL(50, thePackEngine.bins()[3]->locY());
CHECK_EQUAL(40, thePackEngine.bins()[3]->sizX());
CHECK_EQUAL(19, thePackEngine.bins()[3]->sizY());
}
TEST( MergePairs3 )
{
pack2::cPackEngine thePackEngine;
pack2::bin_t b;
// equal spaces adjacent left/right left lower
b = pack2::bin_t( new pack2::cBin( "Bin1", 100, 100 ));
thePackEngine.add( b );
thePackEngine.add( pack2::bin_t( new pack2::cBin( b, 50, 50, 20, 20 )));
thePackEngine.add( pack2::bin_t( new pack2::cBin( b, 30, 51, 20, 20 )));
MergePairs( thePackEngine, b );
// for( pack2::bin_t b : thePackEngine.bins() )
// std::cout << b->text();
CHECK_EQUAL( 4, (int)thePackEngine.bins().size() );
CHECK_EQUAL(50, thePackEngine.bins()[1]->locX());
CHECK_EQUAL(50, thePackEngine.bins()[1]->locY());
CHECK_EQUAL(20, thePackEngine.bins()[1]->sizX());
CHECK_EQUAL( 1, thePackEngine.bins()[1]->sizY());
CHECK_EQUAL(30, thePackEngine.bins()[2]->locX());
CHECK_EQUAL(70, thePackEngine.bins()[2]->locY());
CHECK_EQUAL(20, thePackEngine.bins()[2]->sizX());
CHECK_EQUAL( 1, thePackEngine.bins()[2]->sizY());
CHECK_EQUAL(30, thePackEngine.bins()[3]->locX());
CHECK_EQUAL(51, thePackEngine.bins()[3]->locY());
CHECK_EQUAL(40, thePackEngine.bins()[3]->sizX());
CHECK_EQUAL(19, thePackEngine.bins()[3]->sizY());
}
TEST( MergePairs4 )
{
pack2::cPackEngine thePackEngine;
pack2::bin_t b;
// equal spaces adjacentup/down even
b = pack2::bin_t( new pack2::cBin( "Bin1", 100, 100 ));
thePackEngine.add( b );
thePackEngine.add( pack2::bin_t( new pack2::cBin( b, 50, 50, 20, 20 )));
thePackEngine.add( pack2::bin_t( new pack2::cBin( b, 50, 30, 20, 20 )));
MergePairs( thePackEngine, b );
// for( pack2::bin_t b : thePackEngine.bins() )
// std::cout << b->text();
CHECK_EQUAL( 2, (int)thePackEngine.bins().size() );
CHECK_EQUAL(50, thePackEngine.bins()[1]->locX());
CHECK_EQUAL(30, thePackEngine.bins()[1]->locY());
CHECK_EQUAL(20, thePackEngine.bins()[1]->sizX());
CHECK_EQUAL(40, thePackEngine.bins()[1]->sizY());
}
TEST( MergePairs5 )
{
pack2::cPackEngine thePackEngine;
pack2::bin_t b;
// equal spaces adjacent up/down top to left
b = pack2::bin_t( new pack2::cBin( "Bin1", 100, 100 ));
thePackEngine.add( b );
thePackEngine.add( pack2::bin_t( new pack2::cBin( b, 50, 50, 20, 20 )));
thePackEngine.add( pack2::bin_t( new pack2::cBin( b, 49, 30, 20, 20 )));
MergePairs( thePackEngine, b );
// for( pack2::bin_t b : thePackEngine.bins() )
// std::cout << b->text();
CHECK_EQUAL( 4, (int)thePackEngine.bins().size() );
CHECK_EQUAL(69, thePackEngine.bins()[1]->locX());
CHECK_EQUAL(50, thePackEngine.bins()[1]->locY());
CHECK_EQUAL(1, thePackEngine.bins()[1]->sizX());
CHECK_EQUAL(20, thePackEngine.bins()[1]->sizY());
CHECK_EQUAL(49, thePackEngine.bins()[2]->locX());
CHECK_EQUAL(30, thePackEngine.bins()[2]->locY());
CHECK_EQUAL(1, thePackEngine.bins()[2]->sizX());
CHECK_EQUAL( 20, thePackEngine.bins()[2]->sizY());
CHECK_EQUAL(50, thePackEngine.bins()[3]->locX());
CHECK_EQUAL(30, thePackEngine.bins()[3]->locY());
CHECK_EQUAL(19, thePackEngine.bins()[3]->sizX());
CHECK_EQUAL(40, thePackEngine.bins()[3]->sizY());
}
TEST( MergePairs6 )
{
pack2::cPackEngine thePackEngine;
pack2::bin_t b;
// equal spaces adjacent up/down top to right
b = pack2::bin_t( new pack2::cBin( "Bin1", 100, 100 ));
thePackEngine.add( b );
thePackEngine.add( pack2::bin_t( new pack2::cBin( b, 50, 50, 20, 20 )));
thePackEngine.add( pack2::bin_t( new pack2::cBin( b, 51, 30, 20, 20 )));
MergePairs( thePackEngine, b );
// for( pack2::bin_t b : thePackEngine.bins() )
// std::cout << b->text();
CHECK_EQUAL( 4, (int)thePackEngine.bins().size() );
CHECK_EQUAL(50, thePackEngine.bins()[1]->locX());
CHECK_EQUAL(50, thePackEngine.bins()[1]->locY());
CHECK_EQUAL(1, thePackEngine.bins()[1]->sizX());
CHECK_EQUAL(20, thePackEngine.bins()[1]->sizY());
CHECK_EQUAL(70, thePackEngine.bins()[2]->locX());
CHECK_EQUAL(30, thePackEngine.bins()[2]->locY());
CHECK_EQUAL(1, thePackEngine.bins()[2]->sizX());
CHECK_EQUAL( 20, thePackEngine.bins()[2]->sizY());
CHECK_EQUAL(51, thePackEngine.bins()[3]->locX());
CHECK_EQUAL(30, thePackEngine.bins()[3]->locY());
CHECK_EQUAL(19, thePackEngine.bins()[3]->sizX());
CHECK_EQUAL(40, thePackEngine.bins()[3]->sizY());
}
TEST( MergePairs7 )
{
pack2::cPackEngine thePackEngine;
pack2::bin_t b;
// equal spaces adjacent up/down top to right
b = pack2::bin_t( new pack2::cBin( "Bin1", 100, 100 ));
thePackEngine.add( b );
thePackEngine.add( pack2::bin_t( new pack2::cBin( b, 51, 30, 20, 20 )));
thePackEngine.add( pack2::bin_t( new pack2::cBin( b, 50, 50, 20, 20 )));
MergePairs( thePackEngine, b );
// for( pack2::bin_t b : thePackEngine.bins() )
// std::cout << b->text();
}
int main()
{
pack2::cPackEngine thePackEngine;
pack2::bin_t b;
raven::set::UnitTest::RunAllTests();
thePackEngine.clear();
b = pack2::bin_t( new pack2::cBin( "Bin1", 100, 100 ));
b->copyEnable();
thePackEngine.add( b );
thePackEngine.addItem( "Item1", 10, 10 );
thePackEngine.addItem( "Item2", 10, 10 );
thePackEngine.addItem( "Item3", 10, 10 );
thePackEngine.addItem( "Item4", 10, 10 );
Pack( thePackEngine );
if( BinCount( thePackEngine ) != 1 )
{
std::cout << "Failed 1\n";
return 1;
}
//cout << CSV( thePackEngine );
thePackEngine.clear();
b = pack2::bin_t( new pack2::cBin( "Bin1", 100, 100 ));
b->copyEnable();
thePackEngine.add( b );
thePackEngine.addItem( "Item1", 10, 10 );
thePackEngine.addItem( "Item2", 100, 100 );
Pack( thePackEngine );
if( BinCount( thePackEngine ) != 2 )
{
std::cout << "Failed 2\n";
return 1;
}
//cout << CSV( thePackEngine );
int p = 0;
for( pack2::bin_t b : thePackEngine.bins() )
{
p++;
switch( p )
{
case 1:
if( b->contents().size() != 1 )
{
std::cout << "Failed 3\n";
return false;
}
if( b->contents()[0]->userID() != "Item2" )
{
std::cout << "Failed 4\n";
return false;
}
break;
case 2:
if( b->contents().size() != 1 )
{
std::cout << "Failed 5\n";
return false;
}
if( b->contents()[0]->userID() != "Item1" )
{
std::cout << "Failed 4\n";
return false;
}
break;
}
}
//cout << "Tests passed\n";
return 0;
}
| 30.616183
| 84
| 0.581622
|
JamesBremner
|
485919b437fcc604bf1bcb5236837e824e733247
| 967
|
cpp
|
C++
|
src/source/SMARTEN.cpp
|
ManuelMcLure/TMCStepper
|
c425c40f0adfa24c1c21ce7d6428bcffc2c921ae
|
[
"MIT"
] | 336
|
2018-03-26T13:51:46.000Z
|
2022-03-21T21:58:47.000Z
|
src/source/SMARTEN.cpp
|
ManuelMcLure/TMCStepper
|
c425c40f0adfa24c1c21ce7d6428bcffc2c921ae
|
[
"MIT"
] | 218
|
2017-07-28T06:13:53.000Z
|
2022-03-26T16:41:21.000Z
|
src/source/SMARTEN.cpp
|
ManuelMcLure/TMCStepper
|
c425c40f0adfa24c1c21ce7d6428bcffc2c921ae
|
[
"MIT"
] | 176
|
2018-09-11T22:16:27.000Z
|
2022-03-26T13:04:03.000Z
|
#include "TMCStepper.h"
#include "TMC_MACROS.h"
#define SET_REG(SETTING) SMARTEN_register.SETTING = B; write(SMARTEN_register.address, SMARTEN_register.sr)
#define GET_REG(SETTING) return SMARTEN_register.SETTING
uint32_t TMC2660Stepper::SMARTEN() { return SMARTEN_register.sr; }
void TMC2660Stepper::SMARTEN(uint32_t data) {
SMARTEN_register.sr = data;
write(SMARTEN_register.address, SMARTEN_register.sr);
}
void TMC2660Stepper::seimin(bool B) { SET_REG(seimin); }
void TMC2660Stepper::sedn(uint8_t B) { SET_REG(sedn); }
void TMC2660Stepper::semax(uint8_t B) { SET_REG(semax); }
void TMC2660Stepper::seup(uint8_t B) { SET_REG(seup); }
void TMC2660Stepper::semin(uint8_t B) { SET_REG(semin); }
bool TMC2660Stepper::seimin() { GET_REG(seimin); }
uint8_t TMC2660Stepper::sedn() { GET_REG(sedn); }
uint8_t TMC2660Stepper::semax() { GET_REG(semax); }
uint8_t TMC2660Stepper::seup() { GET_REG(seup); }
uint8_t TMC2660Stepper::semin() { GET_REG(semin); }
| 40.291667
| 107
| 0.752844
|
ManuelMcLure
|
4860c1ffbb99f39d02be1e4d1e1eaface023bf3a
| 22,455
|
cc
|
C++
|
tests/mps_statespace_test.cc
|
cognigami/qsim
|
e18c2f4dc3d1fd7edda696c78ed39708942b47e7
|
[
"Apache-2.0"
] | 280
|
2020-03-04T18:30:16.000Z
|
2022-03-24T15:30:50.000Z
|
tests/mps_statespace_test.cc
|
cognigami/qsim
|
e18c2f4dc3d1fd7edda696c78ed39708942b47e7
|
[
"Apache-2.0"
] | 274
|
2020-03-07T21:10:52.000Z
|
2022-03-30T19:45:48.000Z
|
tests/mps_statespace_test.cc
|
cognigami/qsim
|
e18c2f4dc3d1fd7edda696c78ed39708942b47e7
|
[
"Apache-2.0"
] | 91
|
2020-03-06T18:58:55.000Z
|
2022-03-23T13:32:14.000Z
|
// Copyright 2019 Google LLC. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://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 "../lib/mps_statespace.h"
#include "../lib/formux.h"
#include "gtest/gtest.h"
namespace qsim {
namespace mps {
namespace {
TEST(MPSStateSpaceTest, Create) {
auto ss = MPSStateSpace<For, float>(1);
auto mps = ss.Create(5, 8);
EXPECT_EQ(mps.num_qubits(), 5);
EXPECT_EQ(mps.bond_dim(), 8);
}
TEST(MPSStateSpaceTest, BlockOffset) {
auto ss = MPSStateSpace<For, float>(1);
auto mps = ss.Create(5, 8);
for (unsigned i = 0; i < ss.Size(mps); ++i) {
mps.get()[i] = i;
}
ASSERT_EQ(ss.GetBlockOffset(mps, 0), 0);
ASSERT_EQ(ss.GetBlockOffset(mps, 1), 32);
ASSERT_EQ(ss.GetBlockOffset(mps, 2), 256 + 32);
ASSERT_EQ(ss.GetBlockOffset(mps, 3), 512 + 32);
ASSERT_EQ(ss.GetBlockOffset(mps, 4), 768 + 32);
}
TEST(MPSStateSpaceTest, SetZero) {
auto ss = MPSStateSpace<For, float>(1);
auto mps = ss.Create(4, 8);
for (unsigned i = 0; i < ss.Size(mps); ++i) {
mps.get()[i] = i;
}
ss.SetStateZero(mps);
for (unsigned i = 0; i < ss.Size(mps); ++i) {
auto expected = 0.0;
if (i == 0 || i == 32 || i == 256 + 32 || i == 512 + 32) {
expected = 1;
}
EXPECT_NEAR(mps.get()[i], expected, 1e-5);
}
}
TEST(MPSStateSpaceTest, Copy) {
auto ss = MPSStateSpace<For, float>(1);
auto mps = ss.Create(10, 8);
auto mps2 = ss.Create(10, 8);
auto mps3 = ss.Create(10, 4);
for (unsigned i = 0; i < ss.Size(mps); ++i) {
mps.get()[i] = i;
}
ASSERT_FALSE(ss.Copy(mps, mps3));
ss.Copy(mps, mps2);
for (unsigned i = 0; i < ss.Size(mps); ++i) {
EXPECT_NEAR(mps.get()[i], mps2.get()[i], 1e-5);
}
}
TEST(MPSStateSpaceTest, ToWaveFunctionZero) {
auto ss = MPSStateSpace<For, float>(1);
auto mps = ss.Create(2, 8);
ss.SetStateZero(mps);
float *wf = new float[8];
ss.ToWaveFunction(mps, wf);
EXPECT_NEAR(wf[0], 1, 1e-5);
for (unsigned i = 1; i < 8; ++i) {
EXPECT_NEAR(wf[i], 0, 1e-5);
}
delete[](wf);
}
TEST(MPSStateSpaceTest, ToWaveFunction3) {
auto ss = MPSStateSpace<For, float>(1);
auto mps = ss.Create(3, 4);
// Set to highly entangled three qubit state.
memset(mps.get(), 0, ss.RawSize(mps));
mps.get()[0] = -0.6622649924853867;
mps.get()[1] = -0.3110490936135273;
mps.get()[2] = 0.681488760344724;
mps.get()[3] = -0.015052443773988289;
mps.get()[8] = -0.537553225765131;
mps.get()[9] = 0.4191539781192369;
mps.get()[10] = -0.31650636199260096;
mps.get()[11] = 0.659674338467379;
mps.get()[16] = -0.21720151603221893;
mps.get()[17] = 0.5354822278022766;
mps.get()[18] = -0.24278810620307922;
mps.get()[19] = 0.12074445933103561;
mps.get()[24] = -0.10164494812488556;
mps.get()[25] = -0.6021595597267151;
mps.get()[26] = 0.49309641122817993;
mps.get()[27] = 0.05576712265610695;
mps.get()[32] = -0.3956003189086914;
mps.get()[33] = -0.1778077632188797;
mps.get()[34] = -0.1472112536430359;
mps.get()[35] = 0.7757846117019653;
mps.get()[40] = 0.3030144274234772;
mps.get()[41] = -0.11498478055000305;
mps.get()[42] = 0.06491414457559586;
mps.get()[43] = -0.22911544144153595;
mps.get()[80] = 0.5297775864601135;
mps.get()[81] = 0.0;
mps.get()[82] = -0.6799570918083191;
mps.get()[83] = 0.41853320598602295;
mps.get()[84] = -0.23835298418998718;
mps.get()[85] = 0.0;
mps.get()[86] = -0.13468137383460999;
mps.get()[87] = 0.0829002782702446;
// Check that the following transformation is carried out:
// wf = einsum('ij,jkl,lm->ikm', *blocks)
float *wf = new float[32];
ss.ToWaveFunction(mps, wf);
EXPECT_NEAR(wf[0], -0.005946025252342224, 1e-4);
EXPECT_NEAR(wf[1], -0.3386073410511017, 1e-4);
EXPECT_NEAR(wf[2], 0.08402486890554428, 1e-4);
EXPECT_NEAR(wf[3], 0.2276899814605713, 1e-4);
EXPECT_NEAR(wf[4], 0.10889682918787003, 1e-4);
EXPECT_NEAR(wf[5], 0.26689958572387695, 1e-4);
EXPECT_NEAR(wf[6], -0.13812999427318573, 1e-4);
EXPECT_NEAR(wf[7], -0.17624962329864502, 1e-4);
EXPECT_NEAR(wf[8], 0.16325148940086365, 1e-4);
EXPECT_NEAR(wf[9], -0.18776941299438477, 1e-4);
EXPECT_NEAR(wf[10], 0.24669288098812103, 1e-4);
EXPECT_NEAR(wf[11], 0.48989138007164, 1e-4);
EXPECT_NEAR(wf[12], 0.18966005742549896, 1e-4);
EXPECT_NEAR(wf[13], 0.204482764005661, 1e-4);
EXPECT_NEAR(wf[14], -0.41462600231170654, 1e-4);
EXPECT_NEAR(wf[15], -0.28409692645072937, 1e-4);
delete[](wf);
}
TEST(MPSStateSpaceTest, ToWaveFunction5) {
auto ss = MPSStateSpace<For, float>(1);
auto mps = ss.Create(5, 4);
// Set to highly entangled five qubit state.
memset(mps.get(), 0, ss.RawSize(mps));
mps.get()[0] = -0.7942508170779394;
mps.get()[1] = -0.08353012422743371;
mps.get()[2] = -0.5956724071158231;
mps.get()[3] = -0.0858062557546432;
mps.get()[8] = 0.6008886732655473;
mps.get()[9] = -0.03348407052200576;
mps.get()[10] = -0.7985104374257858;
mps.get()[11] = 0.013883241380578323;
mps.get()[16] = -0.31778309393577153;
mps.get()[17] = 0.08129081012436856;
mps.get()[18] = -0.17084936092778547;
mps.get()[19] = -0.02218120545861387;
mps.get()[20] = -0.4708915300196999;
mps.get()[21] = 0.5554105084817618;
mps.get()[22] = 0.4771044130233731;
mps.get()[23] = 0.3238455071330493;
mps.get()[24] = -0.255477406163936;
mps.get()[25] = 0.4374921994586982;
mps.get()[26] = -0.5501925628308599;
mps.get()[27] = 0.16130434535302918;
mps.get()[28] = -0.22510697789781603;
mps.get()[29] = 0.05157889931677101;
mps.get()[30] = -0.5462643594366281;
mps.get()[31] = -0.2507242261622358;
mps.get()[32] = -0.257977790582352;
mps.get()[33] = -0.11224285788942705;
mps.get()[34] = -0.29538188714282193;
mps.get()[35] = -0.38072576149146387;
mps.get()[36] = 0.6001487220096956;
mps.get()[37] = 0.1913733701851922;
mps.get()[38] = -0.23636184929019038;
mps.get()[39] = 0.4857749031783798;
mps.get()[40] = 0.10130150715330866;
mps.get()[41] = -0.7391377306145324;
mps.get()[42] = -0.44876238752931974;
mps.get()[43] = 0.4560672064449336;
mps.get()[44] = 0.028438967271747218;
mps.get()[45] = 0.13724346784210212;
mps.get()[46] = 0.003584017578785237;
mps.get()[47] = -0.11987932710918753;
mps.get()[80] = 0.40840303886247986;
mps.get()[81] = 0.0;
mps.get()[82] = 0.07592798473660406;
mps.get()[83] = 0.7192043122227202;
mps.get()[84] = -0.1351739336607331;
mps.get()[85] = 0.31415911338868924;
mps.get()[86] = -0.2543437131216091;
mps.get()[87] = 0.1901822451454096;
mps.get()[88] = -0.49494962111198254;
mps.get()[89] = 0.3938336604677486;
mps.get()[90] = 0.12794790638132017;
mps.get()[91] = 0.23588305655979178;
mps.get()[92] = -0.08352038306191087;
mps.get()[93] = 0.4006572203199725;
mps.get()[94] = 0.36886860844013736;
mps.get()[95] = -0.1586842041599526;
mps.get()[96] = 0.1834561393756626;
mps.get()[97] = 0.0;
mps.get()[98] = 0.19628042396288672;
mps.get()[99] = -0.40233821643752055;
mps.get()[100] = -0.5974332727264484;
mps.get()[101] = 0.19287040617030263;
mps.get()[102] = 0.1053276514717207;
mps.get()[103] = 0.016804190083581708;
mps.get()[104] = -0.263327065774291;
mps.get()[105] = 0.43922624365712193;
mps.get()[106] = 0.10968978610217328;
mps.get()[107] = -0.19665026336865873;
mps.get()[108] = -0.06004766570619344;
mps.get()[109] = -0.028059745847255218;
mps.get()[110] = -0.24855708157570078;
mps.get()[111] = 0.5751767140835897;
mps.get()[112] = 0.25199694912392945;
mps.get()[113] = 0.0;
mps.get()[114] = -0.05739258827501658;
mps.get()[115] = -0.30245742194728265;
mps.get()[116] = 0.13607116127541907;
mps.get()[117] = 0.17118330269631235;
mps.get()[118] = -0.22592603732824876;
mps.get()[119] = 0.27239431845297707;
mps.get()[120] = 0.01047777976886481;
mps.get()[121] = -0.21390579587098454;
mps.get()[122] = 0.020345493365053653;
mps.get()[123] = -0.15489716040222756;
mps.get()[124] = -0.2920457586238394;
mps.get()[125] = 0.32807225065061896;
mps.get()[126] = -0.22441139544567443;
mps.get()[127] = -0.15516902178850114;
mps.get()[128] = 0.1303815766294433;
mps.get()[129] = 0.0;
mps.get()[130] = 0.09443469130980126;
mps.get()[131] = 0.09749552478738743;
mps.get()[132] = 0.07115934313302229;
mps.get()[133] = 0.07172860752123576;
mps.get()[134] = 0.35262084813015576;
mps.get()[135] = 0.05559150244274026;
mps.get()[136] = 0.05585983377252125;
mps.get()[137] = -0.08787607283694769;
mps.get()[138] = -0.02888091663074432;
mps.get()[139] = 0.12419549395557358;
mps.get()[140] = -0.24857309811183348;
mps.get()[141] = -0.06536920925603362;
mps.get()[142] = -0.026777844823335055;
mps.get()[143] = 0.07798739264017497;
mps.get()[144] = -0.4022885859012604;
mps.get()[145] = 0.529089629650116;
mps.get()[146] = 0.021047838032245636;
mps.get()[147] = 0.11089000850915909;
mps.get()[152] = -0.11812450736761093;
mps.get()[153] = -0.3155742883682251;
mps.get()[154] = -0.025639047846198082;
mps.get()[155] = 0.5808156132698059;
mps.get()[160] = 0.0904598981142044;
mps.get()[161] = -0.03687569126486778;
mps.get()[162] = 0.4893633723258972;
mps.get()[163] = 0.2733270823955536;
mps.get()[168] = 0.2756871283054352;
mps.get()[169] = -0.2685239017009735;
mps.get()[170] = 0.0703665167093277;
mps.get()[171] = -0.11739754676818848;
mps.get()[176] = -0.040402818471193314;
mps.get()[177] = 0.024999519810080528;
mps.get()[178] = 0.2142343968153;
mps.get()[179] = 0.3487721085548401;
mps.get()[184] = -0.38712623715400696;
mps.get()[185] = 0.2719499170780182;
mps.get()[186] = -0.28398218750953674;
mps.get()[187] = -0.12957964837551117;
mps.get()[192] = -0.16253285109996796;
mps.get()[193] = 0.1666962057352066;
mps.get()[194] = 0.029656991362571716;
mps.get()[195] = -0.07687799632549286;
mps.get()[200] = 0.05283937603235245;
mps.get()[201] = 0.06291946768760681;
mps.get()[202] = 0.01979890652000904;
mps.get()[203] = -0.21019403636455536;
mps.get()[208] = -0.7146716713905334;
mps.get()[209] = 0.0;
mps.get()[210] = 0.3957919478416443;
mps.get()[211] = -0.1956116110086441;
mps.get()[212] = -0.28512677550315857;
mps.get()[213] = 0.0;
mps.get()[214] = -0.41377660632133484;
mps.get()[215] = 0.20450012385845184;
// Check that the following transformation is carried out:
// wf = einsum('ij,jkl,lmn,nop,pq->ikmoq', *blocks)
float *wf = new float[128];
ss.ToWaveFunction(mps, wf);
EXPECT_NEAR(wf[0], 0.0027854256331920624, 1e-4);
EXPECT_NEAR(wf[1], -0.14140120148658752, 1e-4);
EXPECT_NEAR(wf[2], 0.030212486162781715, 1e-4);
EXPECT_NEAR(wf[3], 0.05706779286265373, 1e-4);
EXPECT_NEAR(wf[4], -0.09160802513360977, 1e-4);
EXPECT_NEAR(wf[5], -0.05029388517141342, 1e-4);
EXPECT_NEAR(wf[6], -0.06708981841802597, 1e-4);
EXPECT_NEAR(wf[7], -0.06412483751773834, 1e-4);
EXPECT_NEAR(wf[8], -0.0774611234664917, 1e-4);
EXPECT_NEAR(wf[9], 0.27072837948799133, 1e-4);
EXPECT_NEAR(wf[10], -0.003501715138554573, 1e-4);
EXPECT_NEAR(wf[11], -0.2887609601020813, 1e-4);
EXPECT_NEAR(wf[12], 0.016577117145061493, 1e-4);
EXPECT_NEAR(wf[13], 0.1369006335735321, 1e-4);
EXPECT_NEAR(wf[14], 0.08254759013652802, 1e-4);
EXPECT_NEAR(wf[15], 0.20499306917190552, 1e-4);
EXPECT_NEAR(wf[16], 0.17876368761062622, 1e-4);
EXPECT_NEAR(wf[17], -0.02268427424132824, 1e-4);
EXPECT_NEAR(wf[18], 0.05583261698484421, 1e-4);
EXPECT_NEAR(wf[19], 0.10677587240934372, 1e-4);
EXPECT_NEAR(wf[20], 0.018177300691604614, 1e-4);
EXPECT_NEAR(wf[21], 0.26146093010902405, 1e-4);
EXPECT_NEAR(wf[22], -0.19240343570709229, 1e-4);
EXPECT_NEAR(wf[23], -0.12706275284290314, 1e-4);
EXPECT_NEAR(wf[24], 0.1699770838022232, 1e-4);
EXPECT_NEAR(wf[25], 0.26863881945610046, 1e-4);
EXPECT_NEAR(wf[26], -0.10701578855514526, 1e-4);
EXPECT_NEAR(wf[27], -0.03779822587966919, 1e-4);
EXPECT_NEAR(wf[28], -0.06767062097787857, 1e-4);
EXPECT_NEAR(wf[29], 0.05558207631111145, 1e-4);
EXPECT_NEAR(wf[30], 0.06148408725857735, 1e-4);
EXPECT_NEAR(wf[31], -0.03445826843380928, 1e-4);
EXPECT_NEAR(wf[32], -0.018822386860847473, 1e-4);
EXPECT_NEAR(wf[33], -0.007597930729389191, 1e-4);
EXPECT_NEAR(wf[34], -0.0027186088263988495, 1e-4);
EXPECT_NEAR(wf[35], 0.003467019647359848, 1e-4);
EXPECT_NEAR(wf[36], -0.26657143235206604, 1e-4);
EXPECT_NEAR(wf[37], -0.029667221009731293, 1e-4);
EXPECT_NEAR(wf[38], 0.1857101023197174, 1e-4);
EXPECT_NEAR(wf[39], -0.055891260504722595, 1e-4);
EXPECT_NEAR(wf[40], -0.060019031167030334, 1e-4);
EXPECT_NEAR(wf[41], 0.06737485527992249, 1e-4);
EXPECT_NEAR(wf[42], -0.038918495178222656, 1e-4);
EXPECT_NEAR(wf[43], -0.045035410672426224, 1e-4);
EXPECT_NEAR(wf[44], -0.1498071402311325, 1e-4);
EXPECT_NEAR(wf[45], -0.15015973150730133, 1e-4);
EXPECT_NEAR(wf[46], 0.11186741292476654, 1e-4);
EXPECT_NEAR(wf[47], 0.057124655693769455, 1e-4);
EXPECT_NEAR(wf[48], 0.16711947321891785, 1e-4);
EXPECT_NEAR(wf[49], 0.2237841784954071, 1e-4);
EXPECT_NEAR(wf[50], 0.20187999308109283, 1e-4);
EXPECT_NEAR(wf[51], 0.02212279662489891, 1e-4);
EXPECT_NEAR(wf[52], 0.07793829590082169, 1e-4);
EXPECT_NEAR(wf[53], -0.11144962906837463, 1e-4);
EXPECT_NEAR(wf[54], 0.11177311837673187, 1e-4);
EXPECT_NEAR(wf[55], -0.02343379706144333, 1e-4);
EXPECT_NEAR(wf[56], -0.08419902622699738, 1e-4);
EXPECT_NEAR(wf[57], 0.029235713183879852, 1e-4);
EXPECT_NEAR(wf[58], 0.12327411770820618, 1e-4);
EXPECT_NEAR(wf[59], 0.059630997478961945, 1e-4);
EXPECT_NEAR(wf[60], -0.04118343070149422, 1e-4);
EXPECT_NEAR(wf[61], -0.14594365656375885, 1e-4);
EXPECT_NEAR(wf[62], -0.11883178353309631, 1e-4);
EXPECT_NEAR(wf[63], 0.1824525147676468, 1e-4);
delete[](wf);
}
TEST(MPSStateSpaceTest, InnerProduct4) {
auto ss = MPSStateSpace<For, float>(1);
auto mps = ss.Create(4, 4);
auto mps2 = ss.Create(4, 4);
// Set to highly entangled four qubit state.
memset(mps.get(), 0, ss.RawSize(mps));
memset(mps2.get(), 0, ss.RawSize(mps2));
mps.get()[0] = -0.916497861382668;
mps.get()[1] = -0.0774770100056814;
mps.get()[2] = -0.3905530508872181;
mps.get()[3] = -0.038695257453215746;
mps.get()[8] = 0.39242052841785685;
mps.get()[9] = 0.005926209849421993;
mps.get()[10] = -0.9193660433571464;
mps.get()[11] = -0.027148413259157553;
mps.get()[16] = -0.086494587815096;
mps.get()[17] = -0.5161113650581821;
mps.get()[18] = -0.3716843459879704;
mps.get()[19] = -0.4149275842783076;
mps.get()[20] = 0.3475684513942029;
mps.get()[21] = -0.33731825676083277;
mps.get()[22] = 0.03531924421420863;
mps.get()[23] = 0.4242625462238508;
mps.get()[24] = 0.1548611214464985;
mps.get()[25] = -0.1629745551510658;
mps.get()[26] = -0.3054123508603024;
mps.get()[27] = 0.40742455983835185;
mps.get()[28] = 0.051375370785247995;
mps.get()[29] = 0.6739332289909812;
mps.get()[30] = 0.1957074863128766;
mps.get()[31] = 0.4416548486767887;
mps.get()[32] = -0.4188134561454451;
mps.get()[33] = -0.314779963690704;
mps.get()[34] = 0.594871513074914;
mps.get()[35] = 0.1253634938807484;
mps.get()[36] = -0.3274468059583836;
mps.get()[37] = -0.0033649355295961303;
mps.get()[38] = -0.19836336090039158;
mps.get()[39] = 0.4575368665727339;
mps.get()[40] = -0.4319730509600821;
mps.get()[41] = 0.46315571812161255;
mps.get()[42] = -0.177092245869463;
mps.get()[43] = 0.17165251096868606;
mps.get()[44] = 0.4478329658040191;
mps.get()[45] = 0.028284989048036946;
mps.get()[46] = -0.5484962316855873;
mps.get()[47] = 0.1893602226102037;
mps.get()[80] = 0.5355256929496379;
mps.get()[81] = 0.0;
mps.get()[82] = -0.82749362448062;
mps.get()[83] = 0.02904044194569624;
mps.get()[84] = 0.0;
mps.get()[85] = 3.1712172333499e-18;
mps.get()[88] = 0.08673107202101067;
mps.get()[89] = -0.26957426786565664;
mps.get()[90] = 0.10136853320009953;
mps.get()[91] = -0.16847174758615416;
mps.get()[96] = 0.7256882794862672;
mps.get()[97] = 0.0;
mps.get()[98] = 0.49992356328580695;
mps.get()[99] = -0.07465158451531788;
mps.get()[100] = 0.0;
mps.get()[101] = -2.73164461529292e-18;
mps.get()[104] = -0.11096745459559126;
mps.get()[105] = -0.11248021223295962;
mps.get()[106] = -0.015939524128979008;
mps.get()[107] = -0.04834685546748854;
mps.get()[112] = -0.09137803308510727;
mps.get()[113] = 0.0;
mps.get()[114] = 0.041828533843678406;
mps.get()[115] = -0.055516336152773675;
mps.get()[116] = -1.7346894763697954e-17;
mps.get()[117] = -7.589266459117856e-18;
mps.get()[120] = -0.06982795298266756;
mps.get()[121] = -0.2607434376975409;
mps.get()[122] = 0.04055209540168665;
mps.get()[123] = -0.0998159882317749;
mps.get()[128] = -0.0013533723870614552;
mps.get()[129] = 0.0;
mps.get()[130] = 0.0030153696871580518;
mps.get()[131] = -0.0007536486755610136;
mps.get()[132] = 1.3706310124710953e-17;
mps.get()[133] = 5.271657740273443e-18;
mps.get()[136] = 0.009007639720827557;
mps.get()[137] = 0.01160295765732885;
mps.get()[138] = -0.002650020644033365;
mps.get()[139] = -0.0347660454843333;
mps.get()[144] = 0.7934826958343173;
mps.get()[145] = 0.2097612636620367;
mps.get()[146] = 0.40098701589649566;
mps.get()[147] = 0.06292071832569604;
mps.get()[148] = 0.17644861904250161;
mps.get()[149] = 0.02508862414716359;
mps.get()[150] = -0.36011160812021614;
mps.get()[151] = -0.013850284789667294;
// Set to slightly different four qubit state.
mps2.get()[0] = -0.916497861382668;
mps2.get()[1] = -0.0774770100056814;
mps2.get()[2] = -0.3905530508872181;
mps2.get()[3] = -0.038695257453215746;
mps2.get()[8] = 0.39242052841785685;
mps2.get()[9] = 0.005926209849421993;
mps2.get()[10] = -0.9193660433571464;
mps2.get()[11] = -0.027148413259157553;
mps2.get()[16] = -0.38520893663443145;
mps2.get()[17] = -0.08313325347846491;
mps2.get()[18] = 0.37387886041396534;
mps2.get()[19] = 0.7642074712965752;
mps2.get()[20] = -0.27881372303099244;
mps2.get()[21] = 0.1474857317523121;
mps2.get()[22] = -0.1410007330015855;
mps2.get()[23] = -0.039168047247753496;
mps2.get()[24] = -0.0590745502568466;
mps2.get()[25] = 0.11761847202902623;
mps2.get()[26] = 0.11269537822823146;
mps2.get()[27] = -0.3086460273383095;
mps2.get()[28] = -0.6327237072338668;
mps2.get()[29] = -0.28314375337094555;
mps2.get()[30] = -0.15819977431031695;
mps2.get()[31] = -0.6075990707063283;
mps2.get()[32] = 0.8082960956126871;
mps2.get()[33] = 0.4057876159937702;
mps2.get()[34] = 0.12408608368116913;
mps2.get()[35] = 0.3850457786727492;
mps2.get()[36] = -0.029431664112584088;
mps2.get()[37] = -0.08738621657419658;
mps2.get()[38] = -0.039495020284007906;
mps2.get()[39] = -0.0909603999525164;
mps2.get()[40] = 0.0164446476145238;
mps2.get()[41] = 0.095406687086266;
mps2.get()[42] = 0.015460689255213836;
mps2.get()[43] = -0.06589597358749627;
mps2.get()[44] = -0.5539889126392532;
mps2.get()[45] = -0.32341135258910775;
mps2.get()[46] = 0.1325213431271281;
mps2.get()[47] = 0.7463144784082719;
mps2.get()[80] = 0.3879496172458074;
mps2.get()[81] = 0.0;
mps2.get()[82] = 0.7012769606101399;
mps2.get()[83] = -0.12695868636166885;
mps2.get()[84] = 1.1103700291614824e-16;
mps2.get()[85] = 4.629873324419367e-18;
mps2.get()[88] = 0.36012400471668854;
mps2.get()[89] = 0.11784653120900945;
mps2.get()[90] = -0.5483875743376463;
mps2.get()[91] = -0.1637597971215351;
mps2.get()[92] = 4.775145770909058e-18;
mps2.get()[93] = 1.79364974950039e-17;
mps2.get()[96] = -0.640372512495744;
mps2.get()[97] = 0.0;
mps2.get()[98] = 0.2548579767415688;
mps2.get()[99] = -0.034454109442162505;
mps2.get()[100] = 9.488019311652e-17;
mps2.get()[101] = 1.0530014819474617e-17;
mps2.get()[104] = 0.44752468366493875;
mps2.get()[105] = -0.12895732984521566;
mps2.get()[106] = 0.1804908199125375;
mps2.get()[107] = -0.11201596042542786;
mps2.get()[108] = -1.4515782829099415e-19;
mps2.get()[109] = 4.5471437738577115e-18;
mps2.get()[112] = -0.16454563839144662;
mps2.get()[113] = 0.0;
mps2.get()[114] = -0.024056710061469547;
mps2.get()[115] = -0.1203420866582053;
mps2.get()[116] = -3.1207550335607834e-17;
mps2.get()[117] = -1.1028836460006021e-17;
mps2.get()[120] = -0.13538852421270092;
mps2.get()[121] = 0.17274307394393765;
mps2.get()[122] = -0.15244639495683454;
mps2.get()[123] = -0.06245206468145512;
mps2.get()[124] = -1.5247965666831198e-18;
mps2.get()[125] = 1.4070202389092805e-18;
mps2.get()[128] = 0.03453277422180958;
mps2.get()[129] = 0.0;
mps2.get()[130] = -0.02287709221765174;
mps2.get()[131] = -0.06623554376900025;
mps2.get()[132] = -2.100635435828622e-17;
mps2.get()[133] = 8.534146150309484e-19;
mps2.get()[136] = 0.03199717502952966;
mps2.get()[137] = 0.03835220263481228;
mps2.get()[138] = 0.05616254494558428;
mps2.get()[139] = -0.05491726676672418;
mps2.get()[140] = -1.6687930640538633e-18;
mps2.get()[141] = -1.0473130086052244e-19;
mps2.get()[144] = 0.7934826958343173;
mps2.get()[145] = 0.2097612636620367;
mps2.get()[146] = 0.40098701589649566;
mps2.get()[147] = 0.06292071832569604;
mps2.get()[148] = 0.17644861904250161;
mps2.get()[149] = 0.02508862414716359;
mps2.get()[150] = -0.36011160812021614;
mps2.get()[151] = -0.013850284789667294;
// Computes the following contraction:
// +---+ +---+ +---+ +---+
// mps2 | 0 +-+ 1 +-+ 2 +-+ 3 |
// +-+-+ +-+-+ +-+-+ +-+-+
// | | | |
// | | | |
// +-+-+ +-+-+ +-+-+ +-+-+
// mps | 0 +-+ 1 +-+ 2 +-+ 3 |
// +---+ +---+ +---+ +---+
//
// 0.5524505270081406+0.2471560922399374j
auto r = ss.InnerProduct(mps, mps2);
EXPECT_NEAR(r.real(), 0.5524, 1e-4);
EXPECT_NEAR(r.imag(), 0.2471, 1e-4);
auto f = ss.RealInnerProduct(mps, mps2);
EXPECT_NEAR(f, 0.5524, 1e-4);
}
} // namespace
} // namespace mps
} // namespace qsim
int main(int argc, char **argv) {
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
| 37.613065
| 75
| 0.655578
|
cognigami
|
486245bb7432d5c5d0c5faac89fc61d2babfb35a
| 20,065
|
cpp
|
C++
|
src/histogram.cpp
|
tylern4/clas12_elastic
|
b2630541b1b255a3138a191e61d9a705e25fcef9
|
[
"MIT"
] | null | null | null |
src/histogram.cpp
|
tylern4/clas12_elastic
|
b2630541b1b255a3138a191e61d9a705e25fcef9
|
[
"MIT"
] | null | null | null |
src/histogram.cpp
|
tylern4/clas12_elastic
|
b2630541b1b255a3138a191e61d9a705e25fcef9
|
[
"MIT"
] | 1
|
2019-12-17T16:35:30.000Z
|
2019-12-17T16:35:30.000Z
|
/**************************************/
/* */
/* Created by Nick Tyler */
/* University Of South Carolina */
/**************************************/
#include "histogram.hpp"
Histogram::Histogram(const std::string& output_file) {
RootOutputFile = std::make_shared<TFile>(output_file.c_str(), "RECREATE");
def = std::make_shared<TCanvas>("def");
makeHists();
Nsparce = std::make_shared<THnSparseD>("nsparce", "nsparce", 3, sparce_bins, sparce_xmin, sparce_xmax);
makeHists_electron_cuts();
}
Histogram::~Histogram() { this->Write(); }
void Histogram::Write() {
std::cout << GREEN << "Writting" << DEF << std::endl;
Write_SF();
Nsparce->Write();
std::cout << BOLDBLUE << "WvsQ2()" << DEF << std::endl;
Write_WvsQ2();
std::cout << BOLDBLUE << "Write_MomVsBeta()" << DEF << std::endl;
TDirectory* Write_MomVsBeta_folder = RootOutputFile->mkdir("Mom Vs Beta");
Write_MomVsBeta_folder->cd();
Write_MomVsBeta();
deltaT_proton[before_cut]->Write();
deltaT_proton[after_cut]->Write();
std::cerr << BOLDBLUE << "Write_Electron_cuts()" << DEF << std::endl;
TDirectory* Electron_Cuts = RootOutputFile->mkdir("Electron_Cuts");
Electron_Cuts->cd();
Write_Electron_cuts();
std::cout << BOLDBLUE << "Done Writing!!!" << DEF << std::endl;
}
void Histogram::makeHists() {
deltaT_proton[before_cut] = std::make_shared<TH2D>("DeltaTProton", "DeltaTProton", bins, zero, 10, bins, -5, 5);
deltaT_proton[after_cut] =
std::make_shared<TH2D>("DeltaTProton_cut", "DeltaTProton_cut", bins, zero, 10, bins, -5, 5);
for (short sec = 0; sec < NUM_SECTORS; sec++) {
MissingMass[sec] =
std::make_shared<TH1D>(Form("MM2_hist_sec_%d", sec), Form("MM2_hist_sec_%d", sec), bins, -w_max, w_max);
mass_pi0_hist[before_cut][sec] =
std::make_shared<TH1D>(Form("mass_pi0_hist_%d", sec), Form("mass_pi0_hist_%d", sec), bins, 0, 1.0);
mass_pi0_hist[after_cut][sec] = std::make_shared<TH1D>(Form("mass_pi0_hist_aferPcuts_%d", sec),
Form("mass_pi0_hist_aferPcuts_%d", sec), bins, 0, 1.0);
mass_eta_hist[before_cut][sec] =
std::make_shared<TH1D>(Form("mass_eta_hist_%d", sec), Form("mass_eta_hist_%d", sec), (bins / 2), 0.0, 1.0);
mass_eta_hist[after_cut][sec] = std::make_shared<TH1D>(Form("mass_eta_hist_aferPcuts_%d", sec),
Form("mass_eta_hist_aferPcuts_%d", sec), bins / 2, 0.0, 1.0);
W_hist_all_events[sec] =
std::make_shared<TH1D>(Form("W_hist_sec_%d", sec), Form("W_hist_sec_%d", sec), bins, zero, w_max);
W_hist_1pos[sec] =
std::make_shared<TH1D>(Form("W_hist_1pos_%d", sec), Form("W_hist_1pos_%d", sec), bins, zero, w_max);
W_hist_1pos_0charge[sec] =
std::make_shared<TH1D>(Form("W_hist_1pos_MM0_%d", sec), Form("W_hist_1pos_MM0_%d", sec), bins, zero, w_max);
W_hist_1pos_noOther[sec] = std::make_shared<TH1D>(Form("W_hist_1pos_noOther_%d", sec),
Form("W_hist_1pos_noOther_%d", sec), bins, zero, w_max);
W_vs_q2_all_events[sec] =
std::make_shared<TH2D>(Form("WQ2_sec_%d", sec), Form("WQ2_sec_%d", sec), bins, zero, w_max, bins, zero, q2_max);
W_vs_q2_1pos[sec] = std::make_shared<TH2D>(Form("WQ2_1pos_%d", sec), Form("WQ2_1pos_%d", sec), bins, zero, w_max,
bins, zero, q2_max);
W_vs_q2_1pos_0charge[sec] = std::make_shared<TH2D>(Form("WQ2_1pos_MM0_%d", sec), Form("WQ2_1pos_MM0_%d", sec), bins,
zero, w_max, bins, zero, q2_max);
W_vs_q2_1pos_noOther[sec] = std::make_shared<TH2D>(
Form("WQ2_1pos_noOther_%d", sec), Form("WQ2_1pos_noOther_%d", sec), bins, zero, w_max, bins, zero, q2_max);
for (auto&& det : detector_name) {
int d = detector_fill[det.first];
ThetaVsP[d][sec] =
std::make_shared<TH2D>(Form("MomVsTheta_pos_%s_%d", det.second.c_str(), sec),
Form("MomVsTheta_pos_%s_%d", det.second.c_str(), sec), 500, zero, 6.0, 500, 0, 90);
ThetaVsP_lowW[d][sec] =
std::make_shared<TH2D>(Form("MomVsTheta_lowW_%s_%d", det.second.c_str(), sec),
Form("MomVsTheta_lowW_%s_%d", det.second.c_str(), sec), 500, zero, 6.0, 500, 0, 90);
ThetaVsPCalc[d][sec] =
std::make_shared<TH2D>(Form("MomVsTheta_Calc_%s_%d", det.second.c_str(), sec),
Form("MomVsTheta_Calc_%s_%d", det.second.c_str(), sec), 500, zero, 6.0, 500, 0, 90);
MomVsBeta[d][sec] =
std::make_shared<TH2D>(Form("MomVsBeta_%s_%d", det.second.c_str(), sec),
Form("MomVsBeta_%s_%d", det.second.c_str(), sec), 500, zero, p_max, 500, zero, 1.2);
Phie_vs_Phip[d][sec] =
std::make_shared<TH2D>(Form("Phie_vs_Phip_%s_%d", det.second.c_str(), sec),
Form("Phie_vs_Phip_%s_%d", det.second.c_str(), sec), 500, -PI, PI, 500, -PI, PI);
Phie_Phip_hist[d][sec] =
std::make_shared<TH1D>(Form("Phie_minus_Phip_%s_%d", det.second.c_str(), sec),
Form("Phie_minus_Phip_%s_%d", det.second.c_str(), sec), 500, zero, 2 * PI);
W_hist_1pos_at180[d][sec] =
std::make_shared<TH1D>(Form("W_1pos_at180_%s_%d", det.second.c_str(), sec),
Form("W_1pos_at180_%s_%d", det.second.c_str(), sec), bins, zero, w_max);
W_vs_q2_1pos_at180[d][sec] = std::make_shared<TH2D>(Form("WQ2_1pos_at180_%s_%d", det.second.c_str(), sec),
Form("WQ2_1pos_at180_%s_%d", det.second.c_str(), sec), bins,
zero, w_max, bins, zero, q2_max);
W_hist_1pos_at180_MM[d][sec] =
std::make_shared<TH1D>(Form("W_1pos_at180_MM_%s_%d", det.second.c_str(), sec),
Form("W_1pos_at180_MM_%s_%d", det.second.c_str(), sec), bins, zero, w_max);
W_vs_q2_1pos_at180_MM[d][sec] = std::make_shared<TH2D>(Form("WQ2_1pos_at180_MM_%s_%d", det.second.c_str(), sec),
Form("WQ2_1pos_at180_MM_%s_%d", det.second.c_str(), sec),
bins, zero, w_max, bins, zero, q2_max);
}
}
}
void Histogram::makeHists_electron_cuts() {
for (auto&& cut : before_after_cut) {
int c = cut.first;
auto type = cut.second.c_str();
EC_sampling_fraction[c] =
std::make_shared<TH2D>(Form("EC_sampling_fraction%s", type), Form("EC_sampling_fraction%s", type), bins, p_min,
p_max, bins, zero, 1.0);
vz_position[c] = std::make_shared<TH1D>(Form("vz_position%s", type), Form("vz_position%s", type), bins, -40, 40);
pcal_sec[c] =
std::make_shared<TH2D>(Form("pcal_sec%s", type), Form("pcal_sec%s", type), bins, -420, 420, bins, -420, 420);
dcr1_sec[c] =
std::make_shared<TH2D>(Form("dcr1_sec%s", type), Form("dcr1_sec%s", type), bins, -180, 180, bins, -180, 180);
dcr2_sec[c] =
std::make_shared<TH2D>(Form("dcr2_sec%s", type), Form("dcr2_sec%s", type), bins, -270, 270, bins, -270, 270);
dcr3_sec[c] =
std::make_shared<TH2D>(Form("dcr3_sec%s", type), Form("dcr3_sec%s", type), bins, -320, 320, bins, -320, 320);
}
}
void Histogram::Fill_SF(const std::shared_ptr<Branches12>& _d) {
sf_hist->Fill(_d->p(0), _d->ec_tot_energy(0) / _d->p(0));
}
void Histogram::FillHists_electron_cuts(const std::shared_ptr<Branches12>& _d) {
vz_position[before_cut]->Fill(_d->vz(0));
pcal_sec[before_cut]->Fill(_d->ec_pcal_x(0), _d->ec_pcal_y(0));
dcr1_sec[before_cut]->Fill(_d->dc_r1_x(0), _d->dc_r1_y(0));
dcr2_sec[before_cut]->Fill(_d->dc_r2_x(0), _d->dc_r2_y(0));
dcr3_sec[before_cut]->Fill(_d->dc_r3_x(0), _d->dc_r3_y(0));
EC_sampling_fraction[before_cut]->Fill(_d->p(0), _d->ec_tot_energy(0) / _d->p(0));
}
void Histogram::FillHists_electron_with_cuts(const std::shared_ptr<Branches12>& _d) {
vz_position[after_cut]->Fill(_d->vz(0));
pcal_sec[after_cut]->Fill(_d->ec_pcal_x(0), _d->ec_pcal_y(0));
dcr1_sec[after_cut]->Fill(_d->dc_r1_x(0), _d->dc_r1_y(0));
dcr2_sec[after_cut]->Fill(_d->dc_r2_x(0), _d->dc_r2_y(0));
dcr3_sec[after_cut]->Fill(_d->dc_r3_x(0), _d->dc_r3_y(0));
EC_sampling_fraction[after_cut]->Fill(_d->p(0), _d->ec_tot_energy(0) / _d->p(0));
}
void Histogram::Write_SF() { sf_hist->Write(); }
void Histogram::Write_Electron_cuts() {
for (auto&& cut : before_after_cut) {
int c = cut.first;
vz_position[c]->SetXTitle("vz (GeV)");
if (vz_position[c]->GetEntries()) vz_position[c]->Write();
pcal_sec[c]->SetXTitle("x (cm)");
pcal_sec[c]->SetYTitle("y (cm)");
pcal_sec[c]->SetOption("COLZ1");
if (pcal_sec[c]->GetEntries()) pcal_sec[c]->Write();
dcr1_sec[c]->SetXTitle("x (cm)");
dcr1_sec[c]->SetYTitle("y (cm)");
dcr1_sec[c]->SetOption("COLZ1");
if (dcr1_sec[c]->GetEntries()) dcr1_sec[c]->Write();
dcr2_sec[c]->SetXTitle("x (cm)");
dcr2_sec[c]->SetYTitle("y (cm)");
dcr2_sec[c]->SetOption("COLZ1");
if (dcr2_sec[c]->GetEntries()) dcr2_sec[c]->Write();
dcr3_sec[c]->SetXTitle("x (cm)");
dcr3_sec[c]->SetYTitle("y (cm)");
dcr3_sec[c]->SetOption("COLZ1");
if (dcr3_sec[c]->GetEntries()) dcr3_sec[c]->Write();
EC_sampling_fraction[c]->SetXTitle("Momentum (GeV)");
EC_sampling_fraction[c]->SetYTitle("Sampling Fraction");
EC_sampling_fraction[c]->SetOption("COLZ1");
EC_sampling_fraction[c]->Write();
}
}
void Histogram::Fill_Sparce(const std::shared_ptr<Reaction>& _e) {
std::lock_guard<std::mutex> lk(mutex);
double ret[NUM_DIM] = {_e->W(), _e->Q2(), static_cast<double>(_e->sec())};
Nsparce->Fill(ret);
}
void Histogram::Fill_WvsQ2(const std::shared_ptr<Reaction>& _e) {
short sec = _e->sec();
short pos_det = _e->pos_det();
if ((sec > 0 && sec < NUM_SECTORS) || pos_det != -1) {
W_hist_all_events[all_sectors]->Fill(_e->W());
W_vs_q2_all_events[all_sectors]->Fill(_e->W(), _e->Q2());
W_hist_all_events[sec]->Fill(_e->W());
W_vs_q2_all_events[sec]->Fill(_e->W(), _e->Q2());
if (_e->onePositive()) {
W_hist_1pos[all_sectors]->Fill(_e->W());
W_vs_q2_1pos[all_sectors]->Fill(_e->W(), _e->Q2());
W_hist_1pos[sec]->Fill(_e->W());
W_vs_q2_1pos[sec]->Fill(_e->W(), _e->Q2());
Phie_vs_Phip[both_detectors][all_sectors]->Fill(_e->phi_e(), _e->phi_p());
Phie_Phip_hist[both_detectors][all_sectors]->Fill(_e->phi_diff());
Phie_vs_Phip[both_detectors][sec]->Fill(_e->phi_e(), _e->phi_p());
Phie_Phip_hist[both_detectors][sec]->Fill(_e->phi_diff());
Phie_vs_Phip[pos_det][all_sectors]->Fill(_e->phi_e(), _e->phi_p());
Phie_Phip_hist[pos_det][all_sectors]->Fill(_e->phi_diff());
Phie_vs_Phip[pos_det][sec]->Fill(_e->phi_e(), _e->phi_p());
Phie_Phip_hist[pos_det][sec]->Fill(_e->phi_diff());
}
if (_e->onePositive_MM0()) {
W_hist_1pos_0charge[all_sectors]->Fill(_e->W());
W_vs_q2_1pos_0charge[all_sectors]->Fill(_e->W(), _e->Q2());
W_hist_1pos_0charge[sec]->Fill(_e->W());
W_vs_q2_1pos_0charge[sec]->Fill(_e->W(), _e->Q2());
}
if (_e->onePositive_noOther()) {
W_hist_1pos_noOther[all_sectors]->Fill(_e->W());
W_vs_q2_1pos_noOther[all_sectors]->Fill(_e->W(), _e->Q2());
W_hist_1pos_noOther[sec]->Fill(_e->W());
W_vs_q2_1pos_noOther[sec]->Fill(_e->W(), _e->Q2());
}
if (_e->onePositive_at180()) {
MissingMass[all_sectors]->Fill(_e->MM2());
MissingMass[sec]->Fill(_e->MM2());
W_hist_1pos_at180[both_detectors][all_sectors]->Fill(_e->W());
W_vs_q2_1pos_at180[both_detectors][all_sectors]->Fill(_e->W(), _e->Q2());
W_hist_1pos_at180[both_detectors][sec]->Fill(_e->W());
W_vs_q2_1pos_at180[both_detectors][sec]->Fill(_e->W(), _e->Q2());
W_hist_1pos_at180[pos_det][all_sectors]->Fill(_e->W());
W_vs_q2_1pos_at180[pos_det][all_sectors]->Fill(_e->W(), _e->Q2());
W_hist_1pos_at180[pos_det][sec]->Fill(_e->W());
W_vs_q2_1pos_at180[pos_det][sec]->Fill(_e->W(), _e->Q2());
}
if (_e->onePositive_at180_MM0()) {
W_hist_1pos_at180_MM[both_detectors][all_sectors]->Fill(_e->W());
W_vs_q2_1pos_at180_MM[both_detectors][all_sectors]->Fill(_e->W(), _e->Q2());
W_hist_1pos_at180_MM[both_detectors][sec]->Fill(_e->W());
W_vs_q2_1pos_at180_MM[both_detectors][sec]->Fill(_e->W(), _e->Q2());
W_hist_1pos_at180_MM[pos_det][all_sectors]->Fill(_e->W());
W_vs_q2_1pos_at180_MM[pos_det][all_sectors]->Fill(_e->W(), _e->Q2());
W_hist_1pos_at180_MM[pos_det][sec]->Fill(_e->W());
W_vs_q2_1pos_at180_MM[pos_det][sec]->Fill(_e->W(), _e->Q2());
}
}
}
void Histogram::Write_WvsQ2() {
TDirectory* phi_folder = RootOutputFile->mkdir("Phi");
phi_folder->cd();
for (short j = 0; j < detector_name.size(); j++) {
for (int i = 0; i < NUM_SECTORS; i++) {
Phie_vs_Phip[j][i]->SetXTitle("Phie");
Phie_vs_Phip[j][i]->SetYTitle("Phip");
Phie_vs_Phip[j][i]->SetOption("COLZ");
Phie_vs_Phip[j][i]->Write();
}
for (int i = 0; i < NUM_SECTORS; i++) {
Phie_Phip_hist[j][i]->SetXTitle("Phi");
Phie_Phip_hist[j][i]->Write();
}
}
phi_folder->Write();
delete phi_folder;
TDirectory* at180_folder = RootOutputFile->mkdir("at180");
at180_folder->cd();
for (short j = 0; j < detector_name.size(); j++) {
for (int i = 0; i < NUM_SECTORS; i++) {
W_hist_1pos_at180[j][i]->SetXTitle("W (GeV)");
W_hist_1pos_at180[j][i]->Write();
}
for (int i = 0; i < NUM_SECTORS; i++) {
W_vs_q2_1pos_at180[j][i]->SetXTitle("W (GeV)");
W_vs_q2_1pos_at180[j][i]->SetYTitle("Q^2 (GeV^2)");
W_vs_q2_1pos_at180[j][i]->SetOption("COLZ");
W_vs_q2_1pos_at180[j][i]->Write();
}
}
at180_folder->Write();
delete at180_folder;
TDirectory* at180_MM_folder = RootOutputFile->mkdir("at180_MM");
at180_MM_folder->cd();
for (short j = 0; j < detector_name.size(); j++) {
for (int i = 0; i < NUM_SECTORS; i++) {
W_hist_1pos_at180_MM[j][i]->SetXTitle("W (GeV)");
W_hist_1pos_at180_MM[j][i]->Write();
}
for (int i = 0; i < NUM_SECTORS; i++) {
W_vs_q2_1pos_at180_MM[j][i]->SetXTitle("W (GeV)");
W_vs_q2_1pos_at180_MM[j][i]->SetYTitle("Q^2 (GeV^2)");
W_vs_q2_1pos_at180_MM[j][i]->SetOption("COLZ");
W_vs_q2_1pos_at180_MM[j][i]->Write();
}
}
at180_MM_folder->Write();
delete at180_MM_folder;
TDirectory* W_vs_Q2_folder = RootOutputFile->mkdir("W_vs_Q2");
W_vs_Q2_folder->cd();
for (int i = 0; i < NUM_SECTORS; i++) {
MissingMass[i]->SetXTitle("MM^2 (GeV)");
MissingMass[i]->Write();
mass_pi0_hist[before_cut][i]->SetXTitle("Mass (GeV)");
mass_pi0_hist[before_cut][i]->Write();
mass_pi0_hist[after_cut][i]->SetXTitle("Mass (GeV)");
mass_pi0_hist[after_cut][i]->Write();
mass_eta_hist[before_cut][i]->SetXTitle("Mass (GeV)");
mass_eta_hist[before_cut][i]->Write();
mass_eta_hist[after_cut][i]->SetXTitle("Mass (GeV)");
mass_eta_hist[after_cut][i]->Write();
W_hist_all_events[i]->SetXTitle("W (GeV)");
W_hist_all_events[i]->Write();
W_hist_1pos[i]->SetXTitle("W (GeV)");
W_hist_1pos[i]->Write();
W_hist_1pos_0charge[i]->SetXTitle("W (GeV)");
W_hist_1pos_0charge[i]->Write();
W_hist_1pos_noOther[i]->SetXTitle("W (GeV)");
W_hist_1pos_noOther[i]->Write();
W_vs_q2_all_events[i]->SetXTitle("W (GeV)");
W_vs_q2_all_events[i]->SetYTitle("Q^2 (GeV^2)");
W_vs_q2_all_events[i]->SetOption("COLZ");
W_vs_q2_all_events[i]->Write();
W_vs_q2_1pos[i]->SetXTitle("W (GeV)");
W_vs_q2_1pos[i]->SetYTitle("Q^2 (GeV^2)");
W_vs_q2_1pos[i]->SetOption("COLZ");
W_vs_q2_1pos[i]->Write();
W_vs_q2_1pos_0charge[i]->SetXTitle("W (GeV)");
W_vs_q2_1pos_0charge[i]->SetYTitle("Q^2 (GeV^2)");
W_vs_q2_1pos_0charge[i]->SetOption("COLZ");
W_vs_q2_1pos_0charge[i]->Write();
W_vs_q2_1pos_noOther[i]->SetXTitle("W (GeV)");
W_vs_q2_1pos_noOther[i]->SetYTitle("Q^2 (GeV^2)");
W_vs_q2_1pos_noOther[i]->SetOption("COLZ");
W_vs_q2_1pos_noOther[i]->Write();
}
W_vs_Q2_folder->Write();
delete W_vs_Q2_folder;
}
void Histogram::Fill_MomVsBeta(const std::shared_ptr<Reaction>& _e) {
if (!_e->onePositive_at180()) return;
if (_e->pos_det() == -1) return;
MomVsBeta[both_detectors][all_sectors]->Fill(_e->pos_P(), _e->pos_beta());
MomVsBeta[both_detectors][_e->sec()]->Fill(_e->pos_P(), _e->pos_beta());
ThetaVsP[both_detectors][all_sectors]->Fill(_e->pos_P(), _e->pos_theta());
ThetaVsP[both_detectors][_e->sec()]->Fill(_e->pos_P(), _e->pos_theta());
ThetaVsPCalc[both_detectors][all_sectors]->Fill(_e->pos_P(), _e->pos_theta_calc());
ThetaVsPCalc[both_detectors][_e->sec()]->Fill(_e->pos_P(), _e->pos_theta_calc());
MomVsBeta[_e->pos_det()][all_sectors]->Fill(_e->pos_P(), _e->pos_beta());
MomVsBeta[_e->pos_det()][_e->sec()]->Fill(_e->pos_P(), _e->pos_beta());
ThetaVsP[_e->pos_det()][all_sectors]->Fill(_e->pos_P(), _e->pos_theta());
ThetaVsP[_e->pos_det()][_e->sec()]->Fill(_e->pos_P(), _e->pos_theta());
ThetaVsPCalc[_e->pos_det()][all_sectors]->Fill(_e->pos_P(), _e->pos_theta_calc());
ThetaVsPCalc[_e->pos_det()][_e->sec()]->Fill(_e->pos_P(), _e->pos_theta_calc());
if (_e->W() < 2.0) {
ThetaVsP_lowW[both_detectors][all_sectors]->Fill(_e->pos_P(), _e->pos_theta());
ThetaVsP_lowW[both_detectors][_e->sec()]->Fill(_e->pos_P(), _e->pos_theta());
ThetaVsP_lowW[_e->pos_det()][all_sectors]->Fill(_e->pos_P(), _e->pos_theta());
ThetaVsP_lowW[_e->pos_det()][_e->sec()]->Fill(_e->pos_P(), _e->pos_theta());
}
}
void Histogram::Write_MomVsBeta() {
for (short i = 0; i < detector_name.size(); i++) {
for (short p = 0; p < NUM_SECTORS; p++) {
MomVsBeta[i][p]->SetXTitle("Momentum (GeV)");
MomVsBeta[i][p]->SetYTitle("#beta");
MomVsBeta[i][p]->SetOption("COLZ1");
MomVsBeta[i][p]->Write();
}
for (short p = 0; p < NUM_SECTORS; p++) {
ThetaVsP[i][p]->SetXTitle("Momentum (GeV)");
ThetaVsP[i][p]->SetYTitle("#theta");
ThetaVsP[i][p]->SetOption("COLZ1");
ThetaVsP[i][p]->Write();
}
for (short p = 0; p < NUM_SECTORS; p++) {
ThetaVsP_lowW[i][p]->SetXTitle("Momentum (GeV)");
ThetaVsP_lowW[i][p]->SetYTitle("#theta");
ThetaVsP_lowW[i][p]->SetOption("COLZ1");
ThetaVsP_lowW[i][p]->Write();
}
for (short p = 0; p < NUM_SECTORS; p++) {
ThetaVsPCalc[i][p]->SetXTitle("Momentum (GeV)");
ThetaVsPCalc[i][p]->SetYTitle("#theta");
ThetaVsPCalc[i][p]->SetOption("COLZ1");
ThetaVsPCalc[i][p]->Write();
}
}
}
void Histogram::Fill_Dt(const std::shared_ptr<Delta_T>& dt) {
for (int i = 0; i < dt->gpart(); i++) {
if (dt->charge(i) == 1) deltaT_proton[before_cut]->Fill(dt->mom(i), dt->dt_P(i));
}
}
void Histogram::Fill_Dt(const std::shared_ptr<Delta_T>& dt, int part) {
deltaT_proton[after_cut]->Fill(dt->mom(part), dt->dt_P(part));
}
void Histogram::Fill_pi0(const std::shared_ptr<Reaction>& _e) {
short sec = _e->sec();
short pos_det = _e->pos_det();
for (auto&& m : _e->pair_mass()) {
mass_eta_hist[before_cut][all_sectors]->Fill(m);
if ((sec > 0 && sec < NUM_SECTORS) || pos_det != -1) {
mass_eta_hist[before_cut][sec]->Fill(m);
if (_e->onePositive_at180_MM0()) {
mass_eta_hist[after_cut][all_sectors]->Fill(m);
mass_eta_hist[after_cut][sec]->Fill(m);
}
}
}
if (_e->pi0_mass() < 0.0001) return;
mass_pi0_hist[before_cut][all_sectors]->Fill(_e->pi0_mass());
if ((sec > 0 && sec < NUM_SECTORS) || pos_det != -1) {
mass_pi0_hist[before_cut][sec]->Fill(_e->pi0_mass());
if (_e->onePositive_at180_MM0()) {
mass_pi0_hist[after_cut][all_sectors]->Fill(_e->pi0_mass());
mass_pi0_hist[after_cut][sec]->Fill(_e->pi0_mass());
}
}
}
| 44.293598
| 120
| 0.611313
|
tylern4
|
48643ecb23db6c91908494cc2de207bb205c2929
| 24,199
|
cpp
|
C++
|
src/ibp/widgets/curves.cpp
|
deiflou/ibp
|
9728f7569b59aa261dcaffc8332a1b02c2cd5fbe
|
[
"MIT"
] | 6
|
2015-05-07T18:44:34.000Z
|
2018-12-12T15:57:40.000Z
|
src/ibp/widgets/curves.cpp
|
deiflou/ibp
|
9728f7569b59aa261dcaffc8332a1b02c2cd5fbe
|
[
"MIT"
] | null | null | null |
src/ibp/widgets/curves.cpp
|
deiflou/ibp
|
9728f7569b59aa261dcaffc8332a1b02c2cd5fbe
|
[
"MIT"
] | 2
|
2021-03-22T10:01:32.000Z
|
2021-12-20T05:23:46.000Z
|
//
// MIT License
//
// Copyright (c) Deif Lou
//
// 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 <QPainter>
#include <QMouseEvent>
#include <QKeyEvent>
#include <QVBoxLayout>
#include <math.h>
#include "curves.h"
#include "../misc/util.h"
#include "../misc/nearestneighborsplineinterpolator1D.h"
#include "../misc/linearsplineinterpolator1D.h"
#include "../misc/cubicsplineinterpolator1D.h"
namespace ibp {
namespace widgets {
const QSize Curves::kKnotSize(10, 10);
Curves::Curves(QWidget *parent) :
QWidget(parent),
mZoomFactor(1.),
mOffset(0.),
mIsPeriodic(false),
mIsInputEnabled(true),
mInputStatus(NoStatus),
mKnotIndex(-1),
mSplineInterpolator(0),
mInterpolationMode(Cubic),
mPaintDelegate(0),
mWidgetState(QStyle::State_None),
mKnotStates(2, QStyle::State_None),
mScrollBar(0),
mEmitScrolbarSignals(true)
{
this->setMouseTracking(true);
setFocusPolicy(Qt::StrongFocus);
mSplineInterpolator = new CubicSplineInterpolator1D();
mSplineInterpolator->addKnot(0., 0.);
mSplineInterpolator->addKnot(1., 1.);
mScrollBar = new QScrollBar(Qt::Horizontal, this);
mScrollBar->hide();
QVBoxLayout * layout = new QVBoxLayout(this);
layout->setContentsMargins(kLeftMargin, kTopMargin, kRightMargin, kBottomMargin);
layout->addStretch(1);
layout->addWidget(mScrollBar);
this->connect(mScrollBar, SIGNAL(valueChanged(int)), this, SLOT(On_mScrollBar_valueChanged(int)));
mScrollBar->installEventFilter(this);
updateScrollBar();
}
void Curves::updateScrollBar()
{
int w = graphRect().width();
mScrollBar->setRange(0, w * mZoomFactor - w);
mScrollBar->setValue(mOffset);
mScrollBar->setPageStep(w);
}
QRect Curves::rectWithoutMargins() const
{
return this->rect().adjusted(kLeftMargin, kTopMargin, -kRightMargin,
-kBottomMargin - (mZoomFactor > 1. ? mScrollBar->height() : 0));
}
QRect Curves::graphRect() const
{
return mPaintDelegate ? mPaintDelegate->graphRect(rectWithoutMargins()) : rectWithoutMargins();
}
int Curves::knotUnderCoords(const QPoint &p, bool addKnotIfPossible)
{
QRect gr = graphRect();
double kx, ky;
const double rx = (kKnotSize.width() / 2.) / ((double)gr.width() * mZoomFactor);
const double ry = (kKnotSize.height() / 2.) / ((double)gr.height());
const double x = mapToSplineInterpolator(p.x());
const double y = 1. - (p.y() - gr.top()) / ((double)gr.height());
const double minimumDistance = kMinimumDistanceToAddKnot / ((double)gr.height());
int index = -1;
for (int i = 0; i < mSplineInterpolator->size() - mIsPeriodic ? 1 : 0; i++)
{
kx = mSplineInterpolator->knot(i).x();
ky = mSplineInterpolator->knot(i).y();
if (x > kx - rx && x < kx + rx && y > ky - ry && y < ky + ry)
return i;
}
if (addKnotIfPossible && mSplineInterpolator->size() - (mIsPeriodic ? 1 : 0) < kMaximumNumberOfKnots &&
fabs(IBP_clamp(0., mSplineInterpolator->f(x), 1.) - y) < minimumDistance)
{
if (!mSplineInterpolator->addKnot(x, y, false, &index) || index == -1)
return -1;
const double min = index > 0 ?
mSplineInterpolator->knot(index - 1).x() + kMinimumDistanceBetweenKnots : 0.;
const double max = index < mSplineInterpolator->size() - (mIsPeriodic ? 2 : 1) ?
mSplineInterpolator->knot(index + 1).x() - kMinimumDistanceBetweenKnots : 1.;
mSplineInterpolator->setKnot(index, IBP_clamp(min, x, max), IBP_clamp(0., y, 1.));
if (mIsPeriodic && index == 0)
mSplineInterpolator->setKnot(mSplineInterpolator->size() - 1,
IBP_clamp(min, x, max) + 1., IBP_clamp(0., y, 1.));
if (mKnotIndex >= index)
mKnotIndex++;
mKnotStates.insert(index, QStyle::State_None);
if (mPaintDelegate)
mPaintDelegate->update(CurvesPaintDelegate::KnotsChanged, this, rectWithoutMargins());
emit knotsChanged(mSplineInterpolator->knots());
update();
return index;
}
return -1;
}
void Curves::paintEvent(QPaintEvent *)
{
if (!mPaintDelegate)
return;
QPainter p(this);
p.setRenderHints(QPainter::Antialiasing | QPainter::SmoothPixmapTransform);
QRect r = this->rect().adjusted(kLeftMargin, kTopMargin, -kRightMargin, -kBottomMargin);
// shadow
p.setPen(Qt::NoPen);
p.setBrush(QColor(0, 0, 0, 32));
p.drawRoundedRect(r.adjusted(-2, -1, 2, 3), 3, 3);
p.drawRoundedRect(r.adjusted(-1, 0, 1, 2), 2, 2);
p.setBrush(QColor(0, 0, 0, 50));
p.drawRoundedRect(r.adjusted(0, 1, 0, 1), 1, 1);
// ----
QStyle::State widgetState = mWidgetState |
(isEnabled() ? QStyle::State_Enabled : QStyle::State_None) |
(hasFocus() ? QStyle::State_HasFocus : QStyle::State_None) |
(!mIsInputEnabled ? QStyle::State_ReadOnly : QStyle::State_None);
// ----
if (mZoomFactor > 1.)
r.adjust(0, 0, 0, -mScrollBar->height());
// clip
QPainterPath clippingPath;
clippingPath.addRoundedRect(r, 1, 1);
p.setClipPath(clippingPath);
// graph
QRect graphRectCopy = graphRect();
QPolygonF poly;
for (int i = r.left(); i <= r.right(); i++)
poly.append(QPointF(i, (1. - valueAt(mapToSplineInterpolator(i))) *
graphRectCopy.height() + graphRectCopy.top()));
// knots
QVector<QPointF> knotPositions;
if (graphRectCopy.width() >= kMinimumSizeForInput &&
graphRectCopy.height() >= kMinimumSizeForInput)
for (int i = 0; i < mSplineInterpolator->size() - mIsPeriodic ? 1 : 0; i++)
knotPositions << QPointF(mapFromSplineInterpolator(mSplineInterpolator->knot(i).x()),
(1. - mSplineInterpolator->knot(i).y()) * graphRectCopy.height() +
graphRectCopy.top());
p.save();
mPaintDelegate->paint(p, this, r, widgetState, poly, knotPositions, mKnotStates, kKnotSize);
p.restore();
// focus rect
if (widgetState & QStyle::State_HasFocus)
{
p.setPen(QPen(this->palette().color(QPalette::Highlight), 4));
p.setBrush(Qt::NoBrush);
p.drawRect(r);
}
// paint if disabled
if (!(widgetState & QStyle::State_Enabled))
{
QColor disabledColor = this->palette().color(QPalette::Button);
disabledColor.setAlpha(200);
p.fillRect(r, disabledColor);
}
}
void Curves::mousePressEvent(QMouseEvent * e)
{
if (!mIsInputEnabled || mInputStatus != NoStatus)
return;
QRect gr = graphRect();
if (gr.width() < kMinimumSizeForInput || gr.height() < kMinimumSizeForInput)
return;
int index;
bool mustEmitSignal = false;
if (e->button() == Qt::LeftButton)
{
if (mKnotIndex > -1)
mKnotStates[mKnotIndex] &= ~QStyle::State_Selected;
// add a knot and check if there is a knot in this position
index = knotUnderCoords(e->pos(), true);
mustEmitSignal = index != mKnotIndex;
if (index != -1)
{
mKnotIndex = index;
mInputStatus = DraggingKnot;
mKnotStates[mKnotIndex] |= QStyle::State_Selected | QStyle::State_Sunken;
update();
if (mustEmitSignal)
emit selectedKnotChanged(mKnotIndex);
return;
}
// clicked in non-input area, deselect selected item
mKnotIndex = -1;
mInputStatus = NoStatus;
update();
if (mustEmitSignal)
emit selectedKnotChanged(mKnotIndex);
return;
}
if (e->button() == Qt::RightButton && mSplineInterpolator->size() > (mIsPeriodic ? 3 : 2))
{
index = knotUnderCoords(e->pos());
if (index != -1)
{
mKnotStates.remove(index);
if (index == mKnotIndex)
{
mKnotIndex = -1;
mustEmitSignal = true;
}
else if (mKnotIndex > index)
{
mKnotIndex--;
mustEmitSignal = true;
}
mSplineInterpolator->removeKnot(index);
if (mIsPeriodic && index == 0)
mSplineInterpolator->setKnot(mSplineInterpolator->size() - 1,
mSplineInterpolator->knot(0).x() + 1.,
mSplineInterpolator->knot(0).y());
if (mPaintDelegate)
mPaintDelegate->update(CurvesPaintDelegate::KnotsChanged, this, rectWithoutMargins());
update();
emit knotsChanged(mSplineInterpolator->knots());
if (mustEmitSignal)
emit selectedKnotChanged(mKnotIndex);
return;
}
}
}
void Curves::mouseReleaseEvent(QMouseEvent * e)
{
if (!mIsInputEnabled)
return;
if (e->button() == Qt::LeftButton)
{
for (int i = 0; i < mKnotStates.size(); i++)
mKnotStates[i] &= ~QStyle::State_Sunken;
mInputStatus = NoStatus;
mouseMoveEvent(e);
}
}
void Curves::mouseMoveEvent(QMouseEvent * e)
{
if (!mIsInputEnabled)
return;
mWidgetState = mWidgetState | QStyle::State_MouseOver;
// dragging knot
if (mInputStatus == DraggingKnot && mKnotIndex > -1 && e->buttons() & Qt::LeftButton)
{
QRect gr = graphRect();
QPointF position = e->pos();
const double min = mKnotIndex > 0 ?
mSplineInterpolator->knot(mKnotIndex - 1).x() + kMinimumDistanceBetweenKnots : 0.;
const double max = IBP_minimum(1., mKnotIndex < mSplineInterpolator->size() - 1 ?
mSplineInterpolator->knot(mKnotIndex + 1).x() - kMinimumDistanceBetweenKnots : 1.);
position.setX(IBP_clamp(min, mapToSplineInterpolator(position.x()), max));
position.setY(IBP_clamp(0., 1. - (position.y() - gr.top()) / (double)gr.height(), 1.));
mSplineInterpolator->setKnot(mKnotIndex, position.x(), position.y());
if (mIsPeriodic && mKnotIndex == 0)
mSplineInterpolator->setKnot(mSplineInterpolator->size() - 1,
IBP_maximum(1.001, position.x() + 1.),
position.y());
if (mPaintDelegate)
mPaintDelegate->update(CurvesPaintDelegate::KnotsChanged, this, rectWithoutMargins());
update();
emit knotsChanged(mSplineInterpolator->knots());
return;
}
// not dragging
this->unsetCursor();
if (!rectWithoutMargins().contains(e->pos()))
return;
for (int i = 0; i < mKnotStates.size(); i++)
mKnotStates[i] &= ~QStyle::State_MouseOver;
const int index = knotUnderCoords(e->pos());
if (index != -1)
mKnotStates[index] |= QStyle::State_MouseOver;
update();
}
void Curves::leaveEvent(QEvent *)
{
mWidgetState = mWidgetState & ~QStyle::State_MouseOver;
for (int i = 0; i < mKnotStates.size(); i++)
mKnotStates[i] &= ~QStyle::State_MouseOver;
unsetCursor();
update();
}
void Curves::resizeEvent(QResizeEvent * e)
{
if (e->oldSize().isEmpty())
return;
setOffset(mOffset * e->size().width() / e->oldSize().width());
}
bool Curves::eventFilter(QObject *o, QEvent *e)
{
if (o == mScrollBar && e->type() == QEvent::Enter)
leaveEvent(e);
return false;
}
void Curves::keyPressEvent(QKeyEvent *e)
{
if (mKnotIndex == -1)
return;
Interpolator1DKnot k = mSplineInterpolator->knot(mKnotIndex);
const double min = mKnotIndex > 0 ?
mSplineInterpolator->knot(mKnotIndex - 1).x() + kMinimumDistanceBetweenKnots : 0.;
const double max = IBP_minimum(1., mKnotIndex < mSplineInterpolator->size() - 1 ?
mSplineInterpolator->knot(mKnotIndex + 1).x() - kMinimumDistanceBetweenKnots : 1.);
switch (e->key())
{
case Qt::Key_Right:
if (e->modifiers() & Qt::ControlModifier)
{
mKnotStates[mKnotIndex] &= ~QStyle::State_Selected;
mKnotIndex++;
if (mKnotIndex == mSplineInterpolator->size() - (mIsPeriodic ? 1 : 0))
mKnotIndex--;
mKnotStates[mKnotIndex] |= QStyle::State_Selected;
update();
emit selectedKnotChanged(mKnotIndex);
}
else
{
k.setX(IBP_clamp(min, k.x() + kKeypressIncrement, max));
mSplineInterpolator->setKnot(mKnotIndex, k);
if (mIsPeriodic && mKnotIndex == 0)
mSplineInterpolator->setKnot(mSplineInterpolator->size() - 1, IBP_maximum(1.001, k.x() + 1.), k.y());
if (mPaintDelegate)
mPaintDelegate->update(CurvesPaintDelegate::KnotsChanged, this, rectWithoutMargins());
update();
emit knotsChanged(mSplineInterpolator->knots());
}
break;
case Qt::Key_Left:
if (e->modifiers() & Qt::ControlModifier)
{
mKnotStates[mKnotIndex] &= ~QStyle::State_Selected;
mKnotIndex--;
if (mKnotIndex == -1)
mKnotIndex = 0;
mKnotStates[mKnotIndex] |= QStyle::State_Selected;
update();
emit selectedKnotChanged(mKnotIndex);
}
else
{
k.setX(IBP_clamp(min, k.x() - kKeypressIncrement, max));
mSplineInterpolator->setKnot(mKnotIndex, k);
if (mIsPeriodic && mKnotIndex == 0)
mSplineInterpolator->setKnot(mSplineInterpolator->size() - 1, IBP_maximum(1.001, k.x() + 1.), k.y());
if (mPaintDelegate)
mPaintDelegate->update(CurvesPaintDelegate::KnotsChanged, this, rectWithoutMargins());
update();
emit knotsChanged(mSplineInterpolator->knots());
}
break;
case Qt::Key_Up:
k.setY(IBP_minimum(k.y() + kKeypressIncrement, 1.));
mSplineInterpolator->setKnot(mKnotIndex, k);
if (mIsPeriodic && mKnotIndex == 0)
mSplineInterpolator->setKnot(mSplineInterpolator->size() - 1, k.x() + 1., k.y());
if (mPaintDelegate)
mPaintDelegate->update(CurvesPaintDelegate::KnotsChanged, this, rectWithoutMargins());
update();
emit knotsChanged(mSplineInterpolator->knots());
break;
case Qt::Key_Down:
k.setY(IBP_maximum(k.y() - kKeypressIncrement, 0.));
mSplineInterpolator->setKnot(mKnotIndex, k);
if (mIsPeriodic && mKnotIndex == 0)
mSplineInterpolator->setKnot(mSplineInterpolator->size() - 1, k.x() + 1., k.y());
if (mPaintDelegate)
mPaintDelegate->update(CurvesPaintDelegate::KnotsChanged, this, rectWithoutMargins());
update();
emit knotsChanged(mSplineInterpolator->knots());
break;
default:
QWidget::keyPressEvent(e);
return;
}
}
double Curves::zoomFactor() const
{
return mZoomFactor;
}
double Curves::offset() const
{
return mOffset;
}
bool Curves::isPeriodic() const
{
return mIsPeriodic;
}
bool Curves::isInputEnabled() const
{
return mIsInputEnabled;
}
const Interpolator1DKnots & Curves::knots() const
{
return mSplineInterpolator->knots();
}
int Curves::selectedKnotIndex() const
{
return mKnotIndex;
}
const Interpolator1DKnot & Curves::selectedKnot() const
{
static const Interpolator1DKnot nullSplineInterpolatorKnot;
if (mKnotIndex == -1)
return nullSplineInterpolatorKnot;
return mSplineInterpolator->knot(mKnotIndex);
}
Curves::InterpolationMode Curves::interpolationMode() const
{
return mInterpolationMode;
}
CurvesPaintDelegate *Curves::paintDelegate() const
{
return mPaintDelegate;
}
double Curves::valueAt(double v)
{
return IBP_clamp(0., mSplineInterpolator->f(v), 1.);
}
double Curves::mapToSplineInterpolator(double v) const
{
QRect r = graphRect();
return (v - r.left() + mOffset) / ((r.width() - 1) * mZoomFactor);
}
double Curves::mapFromSplineInterpolator(double v) const
{
QRect r = graphRect();
return (v * (r.width() - 1) * mZoomFactor) - mOffset + r.left();
}
void Curves::setZoomFactor(double v)
{
if (qFuzzyCompare(mZoomFactor, v))
return;
double oldZoomFactor = mZoomFactor;
mZoomFactor = v;
if (v > 1.)
setOffset(mOffset * mZoomFactor / oldZoomFactor);
else
center();
mScrollBar->setVisible(mZoomFactor > 1.);
updateScrollBar();
if (mPaintDelegate)
mPaintDelegate->update(CurvesPaintDelegate::ZoomFactorChanged, this, rectWithoutMargins());
update();
emit zoomFactorChanged(v);
}
void Curves::setOffset(double v)
{
if (qFuzzyCompare(mOffset, v))
return;
int w = graphRect().width();
mOffset = IBP_clamp(0., v, w * mZoomFactor - w);
mEmitScrolbarSignals = false;
updateScrollBar();
mEmitScrolbarSignals = true;
if (mPaintDelegate)
mPaintDelegate->update(CurvesPaintDelegate::OffsetChanged, this, rectWithoutMargins());
update();
emit offsetChanged(v);
}
void Curves::center()
{
int w = graphRect().width();
setOffset((w * mZoomFactor - w) / 2);
}
void Curves::fit()
{
setZoomFactor(1.);
center();
}
void Curves::setPeriodic(bool v)
{
if (mIsPeriodic == v)
return;
mIsPeriodic = v;
if (mIsPeriodic)
{
mSplineInterpolator->addKnot(IBP_maximum(1.001, mSplineInterpolator->knot(0).x() + 1.),
mSplineInterpolator->knot(0).y());
mSplineInterpolator->setExtrapolationMode(Interpolator1D::ExtrapolationMode_Repeat,
Interpolator1D::ExtrapolationMode_Repeat);
if (mInterpolationMode == Cubic)
((CubicSplineInterpolator1D *)mSplineInterpolator)->setBoundaryConditions(
CubicSplineInterpolator1D::BoundaryConditions_Periodic,
CubicSplineInterpolator1D::BoundaryConditions_Periodic);
}
else
{
mSplineInterpolator->removeKnot(mSplineInterpolator->size() - 1);
mSplineInterpolator->setExtrapolationMode(Interpolator1D::ExtrapolationMode_Clamp,
Interpolator1D::ExtrapolationMode_Clamp);
((CubicSplineInterpolator1D *)mSplineInterpolator)->setBoundaryConditions(
CubicSplineInterpolator1D::BoundaryConditions_Natural,
CubicSplineInterpolator1D::BoundaryConditions_Natural);
}
if (mPaintDelegate)
mPaintDelegate->update(CurvesPaintDelegate::PeriodicChanged, this, rectWithoutMargins());
update();
emit periodicChanged(v);
}
void Curves::setInputEnabled(bool v)
{
if (mIsInputEnabled == v)
return;
mIsInputEnabled = v;
if (mPaintDelegate)
mPaintDelegate->update(CurvesPaintDelegate::InputEnabledChanged, this, rectWithoutMargins());
update();
emit inputEnabledChanged(v);
}
void Curves::setKnots(const Interpolator1DKnots &k)
{
mSplineInterpolator->setKnots(k);
mKnotStates = QVector<QStyle::State>(k.size(), QStyle::State_None);
mKnotIndex = -1;
if (mIsPeriodic)
mSplineInterpolator->addKnot(IBP_maximum(1.001, k[0].x() + 1.), k[0].y());
if (mPaintDelegate)
mPaintDelegate->update(CurvesPaintDelegate::KnotsChanged, this, rectWithoutMargins());
update();
emit knotsChanged(k);
emit selectedKnotChanged(mKnotIndex);
}
void Curves::setSelectedKnot(double x, double y)
{
const double min = mKnotIndex > 0 ?
mSplineInterpolator->knot(mKnotIndex - 1).x() + kMinimumDistanceBetweenKnots : 0.;
const double max = mKnotIndex < mSplineInterpolator->size() - 1 ?
mSplineInterpolator->knot(mKnotIndex + 1).x() - kMinimumDistanceBetweenKnots : 1.;
mSplineInterpolator->setKnot(mKnotIndex, IBP_clamp(min, x, max), IBP_clamp(0., y, 1.));
if (mPaintDelegate)
mPaintDelegate->update(CurvesPaintDelegate::KnotsChanged, this, rectWithoutMargins());
update();
emit knotsChanged(mSplineInterpolator->knots());
}
void Curves::setSelectedKnot(const Interpolator1DKnot &k)
{
setSelectedKnot(k.x(), k.y());
}
void Curves::setInterpolationMode(Curves::InterpolationMode m)
{
if (mInterpolationMode == m)
return;
mInterpolationMode = m;
Interpolator1D * tmpSplineInterpolator = mSplineInterpolator;
if (mInterpolationMode == NearestNeighbor)
mSplineInterpolator = new NearestNeighborSplineInterpolator1D();
else if (mInterpolationMode == Linear)
mSplineInterpolator = new LinearSplineInterpolator1D();
else
{
mSplineInterpolator = new CubicSplineInterpolator1D();
((CubicSplineInterpolator1D *)mSplineInterpolator)->setBoundaryConditions(
mIsPeriodic ? CubicSplineInterpolator1D::BoundaryConditions_Periodic :
CubicSplineInterpolator1D::BoundaryConditions_Natural,
mIsPeriodic ? CubicSplineInterpolator1D::BoundaryConditions_Periodic :
CubicSplineInterpolator1D::BoundaryConditions_Natural);
}
mSplineInterpolator->setKnots(tmpSplineInterpolator->knots());
mSplineInterpolator->setExtrapolationMode(tmpSplineInterpolator->floorExtrapolationMode(),
tmpSplineInterpolator->ceilExtrapolationMode(),
tmpSplineInterpolator->floorExtrapolationValue(),
tmpSplineInterpolator->ceilExtrapolationValue());
delete tmpSplineInterpolator;
if (mPaintDelegate)
mPaintDelegate->update(CurvesPaintDelegate::InterpolationModeChanged, this, rectWithoutMargins());
update();
emit interpolationModeChanged(m);
}
void Curves::setPaintDelegate(CurvesPaintDelegate *pd)
{
if (pd == mPaintDelegate)
return;
mPaintDelegate = pd;
if (mPaintDelegate)
{
mPaintDelegate->update(CurvesPaintDelegate::KnotsChanged, this, rectWithoutMargins());
mPaintDelegate->update(CurvesPaintDelegate::ZoomFactorChanged, this, rectWithoutMargins());
mPaintDelegate->update(CurvesPaintDelegate::OffsetChanged, this, rectWithoutMargins());
mPaintDelegate->update(CurvesPaintDelegate::PeriodicChanged, this, rectWithoutMargins());
mPaintDelegate->update(CurvesPaintDelegate::InputEnabledChanged, this, rectWithoutMargins());
mPaintDelegate->update(CurvesPaintDelegate::InterpolationModeChanged, this, rectWithoutMargins());
this->connect(mPaintDelegate, SIGNAL(updateRequired()), this, SLOT(update()));
}
update();
emit paintDelegateChanged(pd);
}
void Curves::On_mScrollBar_valueChanged(int v)
{
if (mEmitScrolbarSignals)
setOffset(v);
}
}}
| 33.377931
| 117
| 0.621637
|
deiflou
|
4864485476c26ac53ed64956481d56ab5bea8033
| 394
|
hh
|
C++
|
src/scorer/scorer.hh
|
RafaelOstertag/tetris
|
ea1abfecdd3f8183331853708291c9943453a962
|
[
"BSD-2-Clause"
] | 1
|
2020-01-02T19:31:58.000Z
|
2020-01-02T19:31:58.000Z
|
src/scorer/scorer.hh
|
RafaelOstertag/tetris
|
ea1abfecdd3f8183331853708291c9943453a962
|
[
"BSD-2-Clause"
] | null | null | null |
src/scorer/scorer.hh
|
RafaelOstertag/tetris
|
ea1abfecdd3f8183331853708291c9943453a962
|
[
"BSD-2-Clause"
] | null | null | null |
#ifndef __SCORER_HH
#define __SCORER_HH
#include <memory>
class Scorer {
public:
using score_t = unsigned int;
using level_t = unsigned int;
virtual ~Scorer() = default;
virtual void scoreLinesRemoved(unsigned int numberOfLines) = 0;
virtual score_t getScore() const = 0;
virtual level_t getLevel() const = 0;
};
using ScorerPtr = std::shared_ptr<Scorer>;
#endif
| 19.7
| 67
| 0.703046
|
RafaelOstertag
|
4866834de98647a54e76f36e535cfbaa5a96f583
| 1,242
|
cpp
|
C++
|
Software/STM32CubeDemo/RotaryEncoderWithDisplay/TouchGFX/generated/fonts/src/Kerning_verdana_22_4bpp.cpp
|
MitkoDyakov/RED
|
3bacb4df47867bbbf23c3c02d0ea1f8faa8d5779
|
[
"MIT"
] | 15
|
2021-09-21T13:55:54.000Z
|
2022-03-08T14:05:39.000Z
|
Software/STM32CubeDemo/RotaryEncoderWithDisplay/TouchGFX/generated/fonts/src/Kerning_verdana_22_4bpp.cpp
|
DynamixYANG/Roendi
|
2f6703d63922071fd0dfc8e4d2c9bba95ea04f08
|
[
"MIT"
] | 7
|
2021-09-22T07:56:52.000Z
|
2022-03-21T17:39:34.000Z
|
Software/STM32CubeDemo/RotaryEncoderWithDisplay/TouchGFX/generated/fonts/src/Kerning_verdana_22_4bpp.cpp
|
DynamixYANG/Roendi
|
2f6703d63922071fd0dfc8e4d2c9bba95ea04f08
|
[
"MIT"
] | 1
|
2022-03-07T07:51:50.000Z
|
2022-03-07T07:51:50.000Z
|
#include <touchgfx/Font.hpp>
FONT_KERNING_LOCATION_FLASH_PRAGMA
KEEP extern const touchgfx::KerningNode kerning_verdana_22_4bpp[] FONT_KERNING_LOCATION_FLASH_ATTRIBUTE = {
{ 0x0054, -2 }, // (First char = [0x0054, T], Second char = [0x003A, :], Kerning dist = -2)
{ 0x0054, 1 }, // (First char = [0x0054, T], Second char = [0x003F, ?], Kerning dist = 1)
{ 0x004C, -2 }, // (First char = [0x004C, L], Second char = [0x0054, T], Kerning dist = -2)
{ 0x0052, -1 }, // (First char = [0x0052, R], Second char = [0x0054, T], Kerning dist = -1)
{ 0x0054, -1 }, // (First char = [0x0054, T], Second char = [0x0054, T], Kerning dist = -1)
{ 0x0065, -1 }, // (First char = [0x0065, e], Second char = [0x0054, T], Kerning dist = -1)
{ 0x0054, -2 }, // (First char = [0x0054, T], Second char = [0x0065, e], Kerning dist = -2)
{ 0x0054, -2 }, // (First char = [0x0054, T], Second char = [0x006F, o], Kerning dist = -2)
{ 0x0054, -2 }, // (First char = [0x0054, T], Second char = [0x0075, u], Kerning dist = -2)
{ 0x004C, -1 }, // (First char = [0x004C, L], Second char = [0x0076, v], Kerning dist = -1)
{ 0x0054, -2 }, // (First char = [0x0054, T], Second char = [0x0076, v], Kerning dist = -2)
};
| 73.058824
| 107
| 0.57971
|
MitkoDyakov
|
4868d517b0680224cfb2a7bdbbb68ee8f1d60784
| 7,146
|
cpp
|
C++
|
servers/src/VisualServer2D.cpp
|
wookie41/blitz
|
7f587bee9b6189c32f0f60c69316bc8deca23c16
|
[
"MIT"
] | 1
|
2020-01-04T21:04:52.000Z
|
2020-01-04T21:04:52.000Z
|
servers/src/VisualServer2D.cpp
|
wookie41/blitz
|
7f587bee9b6189c32f0f60c69316bc8deca23c16
|
[
"MIT"
] | 15
|
2019-08-26T20:54:31.000Z
|
2020-03-15T14:11:44.000Z
|
servers/src/VisualServer2D.cpp
|
wookie41/blitz
|
7f587bee9b6189c32f0f60c69316bc8deca23c16
|
[
"MIT"
] | null | null | null |
#include <servers/VisualServer2D.h>
#include <core/ogl/texture/OpenGLTextureSampler.h>
#include <core/Device.h>
#include <core/Renderer.h>
#include <scene/2d/Canvas.h>
#include <scene/2d/Sprite.h>
#include <blitzmemory/Memory.h>
#include <core/RenderCommand.h>
#include <front/ForwardRenderingPath.h>
#include <platform/fs/FileSystem.h>
#include <core/Texture.h>
#include <blitzmemory/Memory.h>
namespace blitz
{
extern VertexArray* quadVertexArray;
extern Renderer* BLITZ_RENDERER;
extern Device* BLITZ_DEVICE;
static const uint8 MAX_CANVAS_COUNT = 5;
VisualServer2D::VisualServer2D(uint8 numCanvases)
{
memory::resetThreadAllocator();
canvases = new Array<Canvas>(numCanvases);
renderFramePool = new memory::PoolAllocator(5000000);
renderFramePool->init();
renderingPath = new front::ForwardRenderingPath(BLITZ_RENDERER);
}
VisualServer2D::~VisualServer2D() { delete canvases; }
CanvasID VisualServer2D::createCanvas()
{
const uint8 canvasID = canvases->getSize();
assert(canvasID < MAX_CANVAS_COUNT);
canvases->add(Canvas{});
Canvas* canvas = canvases->get(canvasID);
initChildren(canvas);
return canvasID;
}
Canvas* VisualServer2D::getCanvas(CanvasID canvasID) const
{
assert(canvasID < MAX_CANVAS_COUNT);
return canvases->get(canvasID);
}
void VisualServer2D::attachToCanvas(CanvasID canvasID, CanvasItem* item)
{
assert(canvasID < canvases->getSize());
Canvas* canvas = canvases->get(canvasID);
canvas->childrenTail->child = item;
canvas->childrenTail->next = new CanvasChild;
canvas->childrenTail = canvas->childrenTail->next;
}
void VisualServer2D::detachFromCanvas(CanvasID canvasID, CanvasItem* item)
{
assert(canvasID < canvases->getSize());
Canvas* canvas = canvases->get(canvasID);
CanvasChild* prevNode = nullptr;
CanvasChild* childNode = canvas->children;
while (childNode != nullptr)
{
if (childNode->child == item)
{
if (prevNode != nullptr)
{
prevNode->next = childNode->next;
}
childNode->child = nullptr;
childNode->next = nullptr;
return;
}
childNode = childNode->next;
}
}
VisualServer2D* VisualServer2D::getInstance()
{
static VisualServer2D visualServer2D(MAX_CANVAS_COUNT);
return &visualServer2D;
}
Sprite* VisualServer2D::createSprite()
{
Sprite* sprite = new Sprite;
initChildren(sprite);
return sprite;
}
void VisualServer2D::initChildren(CanvasItem* canvasItem) const
{
canvasItem->children = new CanvasChild;
canvasItem->childrenTail = canvasItem->children;
}
void VisualServer2D::render(Framebuffer* target, const ViewPort* viewPort, const front::Camera* camera, const CanvasID& canvasID) const
{
renderFramePool->reset();
memory::setThreadAllocator(renderFramePool);
assert(canvasID < canvases->getSize());
Canvas* canvas = canvases->get(canvasID);
CanvasChild* nodeToRender = canvas->children;
Array<RenderCommand>* renderCanvasCommands = new Array<RenderCommand>(128);
while (nodeToRender->child != nullptr)
{
switch (nodeToRender->child->getType())
{
case CanvasItemType::SPRITE:
renderSprite(target, canvas->transform, (Sprite*)nodeToRender->child, renderCanvasCommands);
break;
}
nodeToRender = nodeToRender->next;
front::RenderList* renderList = new front::RenderList;
renderList->viewPort = viewPort;
renderList->camera = camera;
renderList->framebuffer = target;
renderList->geometry = renderCanvasCommands;
renderList->lights = nullptr;
renderingPath->render(renderList);
}
memory::resetThreadAllocator();
}
void VisualServer2D::renderSprite(Framebuffer* target,
const Transform2D& parentTransfrom,
const Sprite* sprite,
Array<RenderCommand>* commandsBuffer) const
{
static const hash SPRITE_POSITION_UNIFORM_HASH = hashString("_bSpritePosition");
static const hash SPRITE_SIZE_UNIFORM_HASH = hashString("_bSpriteSize");
static const hash SPRITE_TEXTURE_UNIFORM_HASH = hashString("_bSpriteTexture");
static const hash SPRITE_TEXTURE_REGION_SIZE = hashString("_bSpriteTexRegionSize");
static const hash SPRITE_TEXTURE_REGION_INDEX = hashString("_bSpriteTexRegionIndex");
static const hash SPRITE_TEXTURE_SIZE = hashString("_bSpriteTexSize");
commandsBuffer->add(RenderCommand{});
RenderCommand* renderCommand = commandsBuffer->get(commandsBuffer->getSize() - 1);
renderCommand->buffers = nullptr;
renderCommand->drawMode = DrawMode::NORMAL;
renderCommand->numberOfVerticesToDraw = 4;
renderCommand->numberOfIndicesToDraw = 0;
renderCommand->primitiveType = PrimitiveType::TRIANGLE_STRIP;
renderCommand->vertexArray = quadVertexArray;
renderCommand->shader = sprite->material->shader;
size_t materialPropertiesCount = sprite->material->properties == nullptr ? 0 : sprite->material->properties->getSize();
Array<UniformState>* uniformsStates = new Array<UniformState>(6 + materialPropertiesCount);
for (size_t materialPropIdx = 0; materialPropIdx < materialPropertiesCount; ++materialPropIdx)
{
UniformState* materialUniformState = uniformsStates->get(materialPropIdx);
uniformsStates->add(materialUniformState);
}
// TODO sampler should not have to be created every time it should at least be configurable
blitz::TextureSampler* spriteTextureSampler = BLITZ_DEVICE->createSampler(sprite->texture);
uniformsStates->add({ DataType::VECTOR2F, SPRITE_POSITION_UNIFORM_HASH, (void*)&sprite->transform.translate });
uniformsStates->add({ DataType::VECTOR2I, SPRITE_SIZE_UNIFORM_HASH, (void*)&sprite->spriteSize });
uniformsStates->add({ DataType::SAMPLER2D, SPRITE_TEXTURE_UNIFORM_HASH, (void*)spriteTextureSampler });
uniformsStates->add({ DataType::VECTOR2I, SPRITE_TEXTURE_REGION_INDEX, (void*)&sprite->texRegionIndex });
uniformsStates->add({ DataType::VECTOR2I, SPRITE_TEXTURE_REGION_SIZE, (void*)&sprite->texRegionSize });
uniformsStates->add({ DataType::VECTOR3I, SPRITE_TEXTURE_SIZE, (void*)&sprite->texture->getSize() });
renderCommand->uniformsState = uniformsStates;
}
} // namespace blitz
| 37.809524
| 140
| 0.637
|
wookie41
|
4873198941398e47541c9e774b6fff48481642ae
| 14,644
|
cpp
|
C++
|
CFD/src/solver.cpp
|
CompilerLuke/NextEngine
|
aa1a8e9d9370bce004dba00854701597cab74989
|
[
"MIT"
] | 1
|
2021-09-10T18:19:16.000Z
|
2021-09-10T18:19:16.000Z
|
CFD/src/solver.cpp
|
CompilerLuke/NextEngine
|
aa1a8e9d9370bce004dba00854701597cab74989
|
[
"MIT"
] | null | null | null |
CFD/src/solver.cpp
|
CompilerLuke/NextEngine
|
aa1a8e9d9370bce004dba00854701597cab74989
|
[
"MIT"
] | 2
|
2020-04-02T06:46:56.000Z
|
2021-06-17T16:47:57.000Z
|
#include "solver.h"
#include "engine/handle.h"
#include "core/memory/linear_allocator.h"
#include "visualization/debug_renderer.h"
#include "visualization/color_map.h"
#include "vendor/eigen/Eigen/Sparse"
#include "vendor/eigen/Eigen/IterativeLinearSolvers"
using vec_x = Eigen::VectorXd;
using SparseMt = Eigen::SparseMatrix<real>;
using T = Eigen::Triplet<real>;
Eigen::Vector3d to(vec3 vec) { return Eigen::Vector3d(vec.x, vec.y, vec.z); }
vec3 from(Eigen::Vector3d vec) { return vec3(vec[0], vec[1], vec[2]); }
struct Face {
real area;
real dx;
vec3 normal;
real parallel;
vec3 ortho;
uint cell1, cell2;
};
struct BoundaryFace {
real area;
real dx;
vec3 normal;
uint cell;
};
struct PressureBoundaryFace {
real area;
real dx;
vec3 normal;
real pressure;
uint cell;
};
struct Simulation {
CFDDebugRenderer& debug;
uint num_cells;
vector<Face> faces;
vector<BoundaryFace> boundary_faces;
vector<PressureBoundaryFace> pressure_boundary_faces;
SparseMt sparse_matrix;
vec_x source_term;
vector<T> coeffs;
vector<Eigen::Matrix3d> velocity_gradients;
vector<Eigen::Vector3d> pressure_gradients;
vector<vec3> centers;
vector<real> volumes;
vec_x vel_and_pressure;
vector<vec3> velocities_numer;
vector<vec3> velocities_denom;
};
real triangle_area(vec3 v[3]) {
vec3 v01 = v[1] - v[0];
vec3 v02 = v[2] - v[0];
return length(cross(v01, v02))/2.0f;
}
real quad_area(vec3 v[4]) {
vec3 v0[3] = {v[0], v[1], v[2]};
vec3 v1[3] = { v[0], v[2], v[3] };
return triangle_area(v0) + triangle_area(v1);
}
void right_angle_corrector(vec3 normal, vec3 to_center, real* parallel, vec3* ortho) {
to_center = normalize(to_center);
*parallel = dot(normal, to_center);
*ortho = normal - to_center*(*parallel);
}
uint EQ = 4;
uint VAR = 4;
Simulation make_simulation(CFDVolume& mesh, CFDDebugRenderer& debug) {
Simulation result{ debug };
result.num_cells = mesh.cells.length;
result.centers.resize(result.num_cells);
result.volumes.resize(result.num_cells);
result.velocities_numer.resize(result.num_cells);
result.velocities_denom.resize(result.num_cells);
result.velocity_gradients.resize(result.num_cells);
result.pressure_gradients.resize(result.num_cells);
result.vel_and_pressure.resize(VAR * result.num_cells);
result.sparse_matrix.resize(EQ * result.num_cells, VAR * result.num_cells);
for (uint i = 0; i < mesh.cells.length; i++) {
const CFDCell& cell = mesh.cells[i];
const ShapeDesc& shape = shapes[cell.type];
uint cell_id = i;
vec3 center = compute_centroid(mesh, cell.vertices, shape.num_verts);
result.centers[i] = center;
real volume = 0.0f;
for (uint f = 0; f < shape.num_faces; f++) {
const ShapeDesc::Face& face = shape[f];
vec3 face_center;
vec3 v[4];
for (uint j = 0; j < face.num_verts; j++) {
v[j] = mesh.vertices[cell.vertices[face[j]].id].position;
face_center += v[j];
}
face_center /= face.num_verts;
bool is_quad = face.num_verts == 4;
vec3 normal = is_quad ? quad_normal(v) : triangle_normal(v);
real area = is_quad ? quad_area(v) : triangle_area(v);
cell_handle neighbor = cell.faces[f].neighbor;
bool boundary = neighbor.id == -1;
volume += area * dot(face_center, normal);
if (boundary) {
draw_line(debug, face_center, face_center + 0.05*normal, vec4(0,0,0,1));
real dx = 1.0 / (2.0*length(face_center - center));
if (cell.faces[f].pressure_grad != 0.0f) {
result.pressure_boundary_faces.append(PressureBoundaryFace{ area, dx, normal, cell.faces[f].pressure_grad, cell_id });
}
else {
result.boundary_faces.append(BoundaryFace{ area, dx, normal, cell_id });
}
}
else if (neighbor.id > cell_id) {
vec3 center_plus = compute_centroid(mesh, mesh[neighbor].vertices, 8);
vec3 center_minus = center;
vec3 t = center_plus - center_minus;
real ratio = dot(t, normal) / length(t);
result.faces.append(Face{area, 0, normal * ratio, 0, 0, cell_id, (uint)neighbor.id});
}
}
volume /= 3;
result.volumes[cell_id] = volume;
}
for (Face& face : result.faces) {
vec3 center_minus = result.centers[face.cell1];
vec3 center_plus = result.centers[face.cell2];
face.dx = 1.0 / length(center_plus - center_minus);
right_angle_corrector(face.normal, center_plus - center_minus, &face.parallel, &face.ortho);
}
for (uint i = 0; i < result.num_cells; i++) {
result.vel_and_pressure(i*4 + 0) = 0;
result.vel_and_pressure(i*4 + 1) = 0;
result.vel_and_pressure(i*4 + 2) = 0;
result.vel_and_pressure(i*4 + 3) = 1.0;
}
suspend_execution(debug);
return result;
}
vec3 get_velocity(Simulation& simulation, uint cell) {
vec3 result;
result.x = simulation.vel_and_pressure(cell * VAR + 0);
result.y = simulation.vel_and_pressure(cell * VAR + 1);
result.z = simulation.vel_and_pressure(cell * VAR + 2);
return result;
};
real get_pressure(Simulation& simulation, uint cell) {
return simulation.vel_and_pressure[cell * VAR + 3];
};
Eigen::Matrix3d get_velocity_gradient(Simulation& simulation, uint cell) {
return simulation.velocity_gradients[cell];
}
vec3 get_pressure_gradient(Simulation& simulation, uint cell) {
return from(simulation.pressure_gradients[cell]);
}
void compute_gradients(Simulation& simulation) {
auto& velocity_gradients = simulation.velocity_gradients;
auto& pressure_gradients = simulation.pressure_gradients;
for (uint i = 0; i < simulation.num_cells; i++) {
velocity_gradients[i].fill(0.0f);
pressure_gradients[i].fill(0.0f);
}
for (Face f : simulation.faces) {
vec3 velocity_down = get_velocity(simulation, f.cell1);
vec3 velocity_up = get_velocity(simulation, f.cell2);
vec3 velocity = (velocity_down + velocity_up) / 2;
real pressure_down = get_pressure(simulation, f.cell1);
real pressure_up = get_pressure(simulation, f.cell1);
real pressure = (pressure_down + pressure_up) / 2;
Eigen::Vector3d _velocity(velocity.x, velocity.y, velocity.z);
Eigen::Vector3d normal(f.normal.x, f.normal.y, f.normal.z);
normal *= f.area;
Eigen::Matrix3d vel_gradient = _velocity * normal.transpose();
Eigen::Vector3d pressure_gradient = pressure * normal;
velocity_gradients[f.cell1] += vel_gradient;
pressure_gradients[f.cell1] += pressure_gradient;
velocity_gradients[f.cell2] -= vel_gradient;
pressure_gradients[f.cell2] -= pressure_gradient;
}
for (BoundaryFace f : simulation.boundary_faces) {
Eigen::Vector3d normal(f.normal.x, f.normal.y, f.normal.z);
normal *= f.area;
real pressure = get_pressure(simulation, f.cell);
pressure_gradients[f.cell] += pressure * normal;
}
for (PressureBoundaryFace f : simulation.pressure_boundary_faces) {
Eigen::Vector3d velocity = to(get_velocity(simulation, f.cell));
Eigen::Vector3d normal = to(f.normal) * f.area;
real pressure = get_pressure(simulation, f.cell);
velocity_gradients[f.cell] += velocity * normal.transpose();
pressure_gradients[f.cell] += pressure * normal;
}
for (uint i = 0; i < simulation.num_cells; i++) {
velocity_gradients[i] /= simulation.volumes[i];
pressure_gradients[i] /= simulation.volumes[i];
}
}
void build_coupled_matrix(Simulation& simulation) {
vector<T>& coeffs = simulation.coeffs;
vec_x& source = simulation.source_term;
coeffs.clear();
source.resize(simulation.num_cells * EQ);
source.fill(0);
//momentum U coefficient
auto m_U = [&](uint n, uint m, vec3 coeff) {
coeffs.append(T(n*EQ + 0, m*VAR + 0, coeff.x));
coeffs.append(T(n*EQ + 1, m*VAR + 1, coeff.y));
coeffs.append(T(n*EQ + 2, m*VAR + 2, coeff.z));
};
auto m_U_dot = [&](uint n, uint m, vec3 coeff) {
for (uint i = 0; i < 3; i++) {
for (uint j = 0; j < 3; j++) {
coeffs.append(T(n * EQ + i, m * VAR + j, coeff[j]));
}
}
};
auto m_S = [&](uint cell, vec3 value) {
source[cell * EQ + 0] += value.x;
source[cell * EQ + 1] += value.y;
source[cell * EQ + 2] += value.z;
};
//momentum P coefficient
auto m_P = [&](uint c, uint n, vec3 coeff) {
coeffs.append(T(c*EQ + 0, n*VAR + 3, coeff.x));
coeffs.append(T(c*EQ + 1, n*VAR + 3, coeff.y));
coeffs.append(T(c*EQ + 2, n*VAR + 3, coeff.z));
};
//pressure U coefficient, dot product
auto p_U = [&](uint n, uint m, vec3 coeff) {
coeffs.append(T(n*EQ + 3, m*VAR + 0, coeff.x));
coeffs.append(T(n*EQ + 3, m*VAR + 1, coeff.y));
coeffs.append(T(n*EQ + 3, m*VAR + 2, coeff.z));
};
auto p_S = [&](uint c, real value) {
source[c*EQ + 3] += value;
};
//pressure
auto p_P = [&](uint n, uint m, real coeff) {
coeffs.append(T(n*EQ + 3, m*VAR + 3, coeff));
};
auto& vel_and_pressure = simulation.vel_and_pressure;
real rho = 1;
real mu = 1;
auto face_contribution = [&](uint cell, uint neigh, vec3 vel_down, vec3 vel_up, vec3 normal, real parallel, vec3 ortho, real area, real dx) {
vec3 anormal = normal * area;
vec3 pressure_gradient_down = get_pressure_gradient(simulation, cell);
vec3 pressure_gradient_up = get_pressure_gradient(simulation, neigh);
Eigen::Matrix3d vel_gradient_down = get_velocity_gradient(simulation,cell);
Eigen::Matrix3d vel_gradient_up = get_velocity_gradient(simulation, neigh);
vec3 vel_face = (vel_up + vel_down) / 2.0f;
Eigen::Matrix3d vel_gradient_face = (vel_gradient_down + vel_gradient_up) / 2;
vec3 pressure_gradient_face = (pressure_gradient_down + pressure_gradient_up) / 2;
real conv_coeff = rho * dot(vel_face, anormal);
/*
Eigen::Vector3d _anormal = to(anormal);
vec3 div_coeff;
div_coeff.x = vel_gradient_face.col(0).dot(_anormal);
div_coeff.y = vel_gradient_face.col(1).dot(_anormal);
div_coeff.z = vel_gradient_face.col(2).dot(_anormal);
*/
vec3 div_coeff = from(vel_gradient_face.transpose() * to(anormal));
auto& coef = coeffs;
p_U(cell, cell, 10*0.5*anormal);
p_U(cell, neigh, 10*0.5*anormal);
//convective acceleration
m_U(cell, neigh, 0.5*conv_coeff);
m_U(cell, cell, 0.5*conv_coeff);
//pressure source
m_P(cell, neigh, 0.5 * anormal);
m_P(cell, cell, 0.5 * anormal);
//velocity gradient
m_U(cell, neigh, -area * mu * dx * parallel);
m_U(cell, cell, area * mu * dx * parallel);
//orthogonal corrector
m_S(cell, -area * mu * from(vel_gradient_face * to(ortho)));
//pressure gradient
p_P(cell, neigh, area * dx * parallel);
p_P(cell, cell, -area * dx * parallel);
//orthogonal corrector
p_S(cell, -area * dot(pressure_gradient_face, ortho));
//velocity divergence source
p_U(cell, neigh, 0.5 * rho * div_coeff);
p_U(cell, cell, 0.5 * rho * div_coeff);
};
bool first = false;
for (const Face& face : simulation.faces) {
vec3 vel_down = get_velocity(simulation, face.cell1);
vec3 vel_up = get_velocity(simulation, face.cell2);
face_contribution(face.cell1, face.cell2, vel_down, vel_up, face.normal, face.parallel, face.ortho, face.area, face.dx);
face_contribution(face.cell2, face.cell1, vel_up, vel_down, -face.normal, face.parallel, -face.ortho, face.area, face.dx);
}
for (const BoundaryFace& face : simulation.boundary_faces) {
uint cell = face.cell;
real area = face.area;
real dx = face.dx;
vec3 anormal = face.normal * area;
vec3 vel = get_velocity(simulation, cell);
m_P(cell, cell, anormal);
m_U(cell, cell, 2 * area * mu * dx);
}
for (const PressureBoundaryFace& face : simulation.pressure_boundary_faces) {
uint cell = face.cell;
real area = face.area;
real dx = face.dx;
vec3 anormal = face.normal * area;
vec3 vel_face = get_velocity(simulation, cell);
p_U(cell, cell, 10*anormal);
m_U(cell, cell, rho * dot(vel_face, anormal));
m_S(cell, -face.pressure * anormal);
p_P(cell, cell, area * -2 * dx);
source[cell*4 + 3] -= area * 2 * face.pressure * dx;
}
simulation.sparse_matrix.setFromTriplets(coeffs.begin(), coeffs.end());
}
#include <iostream>
void solve_coupled_matrix(Simulation& simulation, bool first) {
Eigen::BiCGSTAB<Eigen::SparseMatrix<real>> solver;
solver.compute(simulation.sparse_matrix);
std::cout << simulation.sparse_matrix << std::endl;
std::cout << simulation.source_term << std::endl;
if (first) {
simulation.vel_and_pressure = solver.solve(simulation.source_term);
}
else {
simulation.vel_and_pressure = solver.solveWithGuess(simulation.source_term, simulation.vel_and_pressure);
}
std::cout << "Solution" << std::endl;
std::cout << simulation.vel_and_pressure << std::endl;
}
void draw_simulation_state(Simulation& simulation, bool show_velocity, bool show_pressure) {
CFDDebugRenderer& debug = simulation.debug;
clear_debug_stack(debug);
float max_pressure = 0.0f;
float max_velocity = 0.0f;
for (uint i = 0; i < simulation.num_cells; i++) {
vec3 vel = get_velocity(simulation, i);
real pressure = get_pressure(simulation, i);
max_pressure = fmaxf(max_pressure, pressure);
max_velocity = fmaxf(max_velocity, length(vel));
}
std::cout << "Max velocity! " << max_velocity << std::endl;
std::cout << "Max pressure! " << max_pressure << std::endl;
if (show_velocity) {
for (uint i = 0; i < simulation.num_cells; i += 1) {
vec3 c = simulation.centers[i];
vec3 u = get_velocity(simulation, i);
vec3 t = normalize(u);
vec3 n = vec3(0, 1, 0);
vec3 b = normalize(cross(t, n));
vec4 color = color_map(length(u), 0, max_velocity);
real l = 0.3*length(u)/max_velocity;
vec3 start = c - t * l / 2;
vec3 end = c + t * l / 2;
float arrow = 0.1 * l;
draw_line(debug, start, end, color);
draw_line(debug, end, end + (n-t)*arrow, color);
draw_line(debug, end, end + (-n-t)*arrow, color);
}
}
if (show_pressure) {
for (uint i = 0; i < simulation.num_cells; i += 1) {
vec3 c = simulation.centers[i];
real p = get_pressure(simulation, i);
real arrow = 0.1;
vec4 color = color_map(p, 0, max_pressure);
draw_line(debug, c + vec3(-arrow, 0, 0), c + vec3(arrow, 0, 0), color);
draw_line(debug, c + vec3(0, -arrow, 0), c + vec3(0, arrow, 0), color);
draw_line(debug, c + vec3(0, 0, -arrow), c + vec3(0, 0, arrow), color);
}
}
}
CFDResults simulate(CFDVolume& volume, CFDDebugRenderer& debug) {
Simulation simulation = make_simulation(volume, debug);
CFDResults result;
uint n = 20;
for (uint i = 0; i < n; i++) {
printf("Iteration %i, (%ix%i)\n", i, simulation.num_cells * 4, simulation.num_cells * 4);
compute_gradients(simulation);
build_coupled_matrix(simulation);
solve_coupled_matrix(simulation, i == 0);
draw_simulation_state(simulation, true, false);
suspend_execution(debug);
draw_simulation_state(simulation, false, true);
suspend_execution(debug);
}
//result.velocities = std::move(simulation.velocities);
//result.pressures = std::move(simulation.pressures);
return result;
}
| 28.99802
| 142
| 0.687449
|
CompilerLuke
|
4877611196a94063f1ece7284bfc9989486d7d8a
| 5,196
|
cc
|
C++
|
nodejs-mobile/deps/chakrashim/src/v8propertydescriptor.cc
|
xuelongqy/cnode
|
ac256264d329e68b6c5ae3281b0e7bb5a95ae164
|
[
"MIT"
] | null | null | null |
nodejs-mobile/deps/chakrashim/src/v8propertydescriptor.cc
|
xuelongqy/cnode
|
ac256264d329e68b6c5ae3281b0e7bb5a95ae164
|
[
"MIT"
] | 4
|
2020-03-13T14:45:49.000Z
|
2020-03-15T16:31:22.000Z
|
nodejs-mobile/deps/chakrashim/src/v8propertydescriptor.cc
|
xuelongqy/cnode
|
ac256264d329e68b6c5ae3281b0e7bb5a95ae164
|
[
"MIT"
] | 1
|
2020-03-15T16:02:18.000Z
|
2020-03-15T16:02:18.000Z
|
// Copyright Microsoft. All rights reserved.
//
// 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 "v8chakra.h"
namespace v8 {
struct PropertyDescriptor::PrivateData {
PrivateData()
: enumerable(false),
has_enumerable(false),
configurable(false),
has_configurable(false),
writable(false),
has_writable(false),
value(JS_INVALID_REFERENCE),
get(JS_INVALID_REFERENCE),
set(JS_INVALID_REFERENCE) {}
bool has_value() { return value != JS_INVALID_REFERENCE; }
bool has_get() { return get != JS_INVALID_REFERENCE; }
bool has_set() { return set != JS_INVALID_REFERENCE; }
bool enumerable : 1;
bool has_enumerable : 1;
bool configurable : 1;
bool has_configurable : 1;
bool writable : 1;
bool has_writable : 1;
JsValueRef value;
JsValueRef get;
JsValueRef set;
};
PropertyDescriptor::PropertyDescriptor() : private_(new PrivateData()) {}
PropertyDescriptor::PropertyDescriptor(Local<Value> value)
: private_(new PrivateData()) {
private_->value = reinterpret_cast<JsValueRef>(*value);
if (private_->value != JS_INVALID_REFERENCE) {
JsAddRef(private_->value, nullptr);
}
}
PropertyDescriptor::PropertyDescriptor(Local<Value> value,
bool writable)
: private_(new PrivateData()) {
private_->value = reinterpret_cast<JsValueRef>(*value);
if (private_->value != JS_INVALID_REFERENCE) {
JsAddRef(private_->value, nullptr);
}
private_->has_writable = true;
private_->writable = writable;
}
PropertyDescriptor::PropertyDescriptor(Local<Value> get,
Local<Value> set)
: private_(new PrivateData()) {
CHAKRA_ASSERT(get.IsEmpty() || get->IsUndefined() || get->IsFunction());
CHAKRA_ASSERT(set.IsEmpty() || set->IsUndefined() || set->IsFunction());
private_->get = reinterpret_cast<JsValueRef>(*get);
private_->set = reinterpret_cast<JsValueRef>(*set);
if (private_->get != JS_INVALID_REFERENCE) {
JsAddRef(private_->get, nullptr);
}
if (private_->set != JS_INVALID_REFERENCE) {
JsAddRef(private_->set, nullptr);
}
}
PropertyDescriptor &
PropertyDescriptor::operator=(PropertyDescriptor && other) {
private_ = other.private_;
other.private_ = nullptr;
return* this;
}
PropertyDescriptor::~PropertyDescriptor() {
if (private_ == nullptr) {
return;
}
if (private_->value != JS_INVALID_REFERENCE) {
JsRelease(private_->value, nullptr);
}
if (private_->get != JS_INVALID_REFERENCE) {
JsRelease(private_->get, nullptr);
}
if (private_->set != JS_INVALID_REFERENCE) {
JsRelease(private_->set, nullptr);
}
delete private_;
}
Local<Value> PropertyDescriptor::value() const {
CHAKRA_ASSERT(private_->has_value());
return Local<Value>::New(private_->value);
}
Local<Value> PropertyDescriptor::get() const {
return Local<Value>::New(private_->get);
}
Local<Value> PropertyDescriptor::set() const {
return Local<Value>::New(private_->set);
}
bool PropertyDescriptor::has_value() const {
return private_->has_value();
}
bool PropertyDescriptor::has_get() const {
return private_->has_get();
}
bool PropertyDescriptor::has_set() const {
return private_->has_set();
}
bool PropertyDescriptor::writable() const {
CHAKRA_ASSERT(private_->has_writable);
return private_->writable;
}
bool PropertyDescriptor::has_writable() const {
return private_->has_writable;
}
void PropertyDescriptor::set_enumerable(bool enumerable) {
private_->has_enumerable = true;
private_->enumerable = enumerable;
}
bool PropertyDescriptor::enumerable() const {
CHAKRA_ASSERT(private_->has_enumerable);
return private_->enumerable;
}
bool PropertyDescriptor::has_enumerable() const {
return private_->has_enumerable;
}
void PropertyDescriptor::set_configurable(bool configurable) {
private_->has_configurable = true;
private_->configurable = configurable;
}
bool PropertyDescriptor::configurable() const {
CHAKRA_ASSERT(private_->has_configurable);
return private_->configurable;
}
bool PropertyDescriptor::has_configurable() const {
return private_->has_configurable;
}
} // namespace v8
| 30.209302
| 80
| 0.71863
|
xuelongqy
|
4879704b1b035e0e4ed35ca52bb52035c93c3cd5
| 42,526
|
cpp
|
C++
|
TBDAnnotation/src/TBDAnnotation.cpp
|
marcorighini/tbdannotation
|
f22d395fce5c6c1007177623b0a0c60f7fcb9d4f
|
[
"Apache-2.0"
] | 1
|
2021-06-13T10:49:43.000Z
|
2021-06-13T10:49:43.000Z
|
TBDAnnotation/src/TBDAnnotation.cpp
|
marcorighini/tbdannotation
|
f22d395fce5c6c1007177623b0a0c60f7fcb9d4f
|
[
"Apache-2.0"
] | null | null | null |
TBDAnnotation/src/TBDAnnotation.cpp
|
marcorighini/tbdannotation
|
f22d395fce5c6c1007177623b0a0c60f7fcb9d4f
|
[
"Apache-2.0"
] | null | null | null |
#include "Model/Page.hpp"
#include "Model/Utils.hpp"
#include "Model/DatabaseHandler.hpp"
#include "Model/RegisteredPdfMap.hpp"
#include "Model/FileManager.hpp"
#include "Model/ImageProcessor.hpp"
#include "Model/Triangle.hpp"
#include "Model/FeaturesManager.hpp"
#include "Model/WebCamCapture.hpp"
#include <iostream>
#include "Model/ProgramOptions.hpp"
#include "Model/StateMachine/StateMachine.hpp"
#include "Model/StateMachine/ExitState.hpp"
#include "Model/StateMachine/PageDiscovering.hpp"
#include "Model/StateMachine/MachineEvents.hpp"
#include "Model/StateMachine/PageRetrieval.hpp"
#include "Model/StateMachine/PageTracking.hpp"
#include "Model/StateMachine/PageError.hpp"
#include "Model/StateMachine/PageAnnotation.hpp"
#include "Model/StateMachine/PdfCreation.hpp"
#include <thread>
#include <X11/Xlib.h>
#include <vector>
int main(int argc, char** argv) {
//##############################################################################//
// PROGRAM OPTIONS
//##############################################################################//
// Program options variables
string appName = "TBDAnnotation";
string subcommand;
string documentsPathString, outputPathString, datasetPathString;
int nSets = 1;
uint nRetained = 1;
string pageNameString;
string calibrationPathString;
bool calibrationSupplied = false;
// Help string
std::string subcommandDesc = std::string("subcommand to execute: calibrate, register, annotate, test");
std::string helpDesc = std::string("print usage messages\n");
std::string documentsPathDesc = std::string("path to pdf documents");
std::string outputPathDesc = std::string("output files directory");
std::string datasetPathDesc = std::string("dataset files directory");
std::string nSetsDesc = std::string(
"number of datasets. The i-th dataset has size i*nPages/nSets. Optional, default=1");
std::string nRetainedDesc = std::string(
"number of same pages that will be present in every dataset. Required if nSets is setted");
std::string pageNameDesc = std::string("name of page to retrieve. Required if test mode enabled");
std::string calibrationPathDesc = std::string("calibration file path. Optional");
// Usage
string usageFirstLine =
"\nUsage:\n"
"TBDAnnotation calibrate [-h] [--output CALIBRATION_OUTPUT_PATH] \n"
"TBDAnnotation register [-h] [--documents DOCUMENTS_PATH] [--output DATASET_OUTPUT_PATH] [--nSets N_SETS] [--nRetained N_RETAINED]\n"
"TBDAnnotation annotate [-h] [--dataset DATASET_PATH] [--output PDF_OUTPUT_PATH] [--calibration CALIBRATION_FILE]\n"
"TBDAnnotation test [-h] [--dataset DATASET_PATH] [--pageName PAGE_NAME] \n\n";
po::options_description desc(usageFirstLine, 120);
// Options
desc.add_options()("help,h", helpDesc.c_str())("documents", po::value(&documentsPathString),
documentsPathDesc.c_str())("output", po::value(&outputPathString), outputPathDesc.c_str())("nSets",
po::value(&nSets), nSetsDesc.c_str())("nRetained", po::value(&nRetained), nRetainedDesc.c_str())("dataset",
po::value(&datasetPathString), datasetPathDesc.c_str())("pageName", po::value(&pageNameString),
pageNameDesc.c_str())("calibration", po::value(&calibrationPathString), calibrationPathDesc.c_str())(
"subcommand", po::value<string>(&subcommand)->required(), subcommandDesc.c_str());
po::positional_options_description positionalOptions;
positionalOptions.add("subcommand", 1);
po::variables_map vm;
try {
// Parse command line
po::store(po::command_line_parser(argc, argv).options(desc).positional(positionalOptions).run(), vm);
if (vm.count("help") || argc == 1) {
std::cout << usageFirstLine;
po::OptionPrinter::printParametersDesc(appName, std::cout, desc, &positionalOptions);
}
// Handle valid subcommands and required options
vector<string> subcommands;
subcommands.push_back("calibrate");
subcommands.push_back("register");
subcommands.push_back("annotate");
subcommands.push_back("test");
po::validate_subcommands(vm, "subcommand", subcommands);
vector<string> subcommand_calibrate_dependencies;
subcommand_calibrate_dependencies.push_back("output");
vector<string> subcommand_register_dependencies;
subcommand_register_dependencies.push_back("documents");
subcommand_register_dependencies.push_back("output");
vector<string> subcommand_annotate_dependencies;
subcommand_annotate_dependencies.push_back("dataset");
subcommand_annotate_dependencies.push_back("output");
vector<string> subcommand_test_dependencies;
subcommand_test_dependencies.push_back("dataset");
subcommand_test_dependencies.push_back("pageName");
po::subcommand_option_dependency(vm, "subcommand", "calibrate", subcommand_calibrate_dependencies);
po::subcommand_option_dependency(vm, "subcommand", "register", subcommand_register_dependencies);
po::subcommand_option_dependency(vm, "subcommand", "annotate", subcommand_annotate_dependencies);
po::subcommand_option_dependency(vm, "subcommand", "test", subcommand_test_dependencies);
po::notify(vm);
if (nSets > 1) {
po::option_dependency(vm, "nSets", "nRetained");
}
po::notify(vm);
// nSets cannot be zero or negative
if (nSets < 1) {
throw std::logic_error(std::string("Option nSets cannot be zero or negative."));
}
// nRetained cannot be zero or negative
if (nRetained < 1) {
throw std::logic_error(std::string("Option nRetained cannot be zero or negative."));
}
// Check if calibration is supplied
if (vm.count("calibration")) {
calibrationSupplied = true;
}
} catch (std::exception& e) {
std::cerr << e.what() << "\n";
return 0;
}
/**********************************************************************************************************/
/**********************************************************************************************************/
if (vm["subcommand"].as<string>().compare("calibrate") == 0) {
//##############################################################################//
// CALIBRATION
//##############################################################################//
string destinationPath(outputPathString);
stringstream filename;
filename << destinationPath << Parameters::ANNOTATIONS_THRESHOLD_FILENAME;
FileStorage fs(filename.str(), FileStorage::WRITE);
if (!fs.isOpened()) {
std::cerr << "ERROR: Can't create file \"" << filename.str() << "\"" << "\n";
return 0;
}
VideoCapture cap(0);
bool drawRectangleOnTruth = true;
// Instructions
cout << "\nPlease, align a completely white sheet into the green rectangle and then\n"
"draw a line (or whatever is enough visible) into each red rectangle.\n"
"Then you have to put your hand in the second half of the window, below the green line.\n"
"In the same area, draw some black lines for text simulation.\n"
"Finally, don't forget to leave visible some part of the background (desk\n"
"or something else) out of the green boundary.\n"
"Take a look to the \"Truth\" window: the goal is to view only lines in the red rectangles.\n"
"\"Truth\" is the mask that the algorithm will try to replicate (note that \"Truth\"\n"
"is given in grayscale mode thanks to the absence of text).\n"
"\n"
"Press 's' to start searching...\n"
"Press 't' to toggle rectangle draw in \"Truth\" window...\n"
"Press 'Esc' to quit...\n";
for (;;) {
Mat frame;
cap >> frame;
ImageProcessor::adjustWebCamImage(frame, Parameters::SELECTED_WEB_CAM_ORIENTATION);
Mat frameGray = frame.clone();
cvtColor(frameGray, frameGray, CV_BGR2GRAY);
// ############################################################# //
// Truth definition section
Mat adaptiveThresh;
adaptiveThreshold(frameGray, adaptiveThresh, Parameters::THRESHOLD_MAX_VALUE, CV_ADAPTIVE_THRESH_GAUSSIAN_C,
CV_THRESH_BINARY, Parameters::ADAPTIVE_THRESHOLD_BLOCK_SIZE,
Parameters::ADAPTIVE_THRESHOLD_CONSTANT);
Mat element = getStructuringElement(Parameters::MORPH_SE_SHAPE, Size(3, 3), Point(1, 1));
morphologyEx(adaptiveThresh, adaptiveThresh, MORPH_CLOSE, element);
Mat truth = adaptiveThresh.clone();
// Clean up
for (int i = 0; i < truth.rows; i++) {
for (int j = 0; j < truth.cols; j++) {
if (!(i >= Parameters::BOUNDARY_MARGIN && i <= truth.rows / 2 && j >= Parameters::BOUNDARY_MARGIN
&& j <= truth.cols - Parameters::BOUNDARY_MARGIN)) {
truth.at<uchar>(i, j) = 255;
}
}
}
// Truth: white foreground
truth = 255 - truth;
// ######################################################
// Rectangles definition section
// Page boundary rectangle
Rect boundaryRect(Point(Parameters::BOUNDARY_MARGIN, Parameters::BOUNDARY_MARGIN),
Point(frame.cols - Parameters::BOUNDARY_MARGIN, frame.rows - Parameters::BOUNDARY_MARGIN));
// Left rectangle
int rectangleSxWidth = 50;
Rect annotationRectSX(
Point(Parameters::BOUNDARY_MARGIN * 2,
(frame.rows / 2 - Parameters::BOUNDARY_MARGIN) / 4 + Parameters::BOUNDARY_MARGIN),
Point(Parameters::BOUNDARY_MARGIN * 2 + rectangleSxWidth,
(frame.rows / 2 - Parameters::BOUNDARY_MARGIN) * 3. / 4 + Parameters::BOUNDARY_MARGIN));
// Right rectangle
int rectangleDxWidth = 50;
Rect annotationRectDX(
Point(frame.cols - (Parameters::BOUNDARY_MARGIN * 2 + rectangleDxWidth),
(frame.rows / 2 - Parameters::BOUNDARY_MARGIN) / 4 + Parameters::BOUNDARY_MARGIN),
Point(frame.cols - Parameters::BOUNDARY_MARGIN * 2,
(frame.rows / 2 - Parameters::BOUNDARY_MARGIN) * 3. / 4 + Parameters::BOUNDARY_MARGIN));
// Top rectangle
int rectangleTopHeight = 50;
Rect annotationRectTOP(
Point((frame.cols - Parameters::BOUNDARY_MARGIN * 2) / 4 + Parameters::BOUNDARY_MARGIN,
Parameters::BOUNDARY_MARGIN * 2),
Point((frame.cols - Parameters::BOUNDARY_MARGIN * 2) * 3. / 4 + Parameters::BOUNDARY_MARGIN,
Parameters::BOUNDARY_MARGIN * 2 + rectangleTopHeight));
// Bottom rectangle
int rectangleBotHeight = 50;
Rect annotationRectBOTTOM(
Point((frame.cols - Parameters::BOUNDARY_MARGIN * 2) / 4 + Parameters::BOUNDARY_MARGIN,
frame.rows / 2 - Parameters::BOUNDARY_MARGIN),
Point((frame.cols - Parameters::BOUNDARY_MARGIN * 2) * 3. / 4 + Parameters::BOUNDARY_MARGIN,
frame.rows / 2 - (Parameters::BOUNDARY_MARGIN + rectangleBotHeight)));
// ############################################################# //
// Rectangles and lines drawing section
Mat frameToShow = frame.clone();
Mat truthToShow;
cvtColor(truth, truthToShow, CV_GRAY2BGR);
// Linea di metà
line(frameToShow, Point(0, frame.rows / 2), Point(frame.cols, frame.rows / 2), Scalar(0, 255, 0), 2, CV_AA);
line(truthToShow, Point(0, frame.rows / 2), Point(frame.cols, frame.rows / 2), Scalar(0, 255, 0), 2, CV_AA);
// Rettangoli vari
rectangle(frameToShow, boundaryRect, Scalar(0, 255, 0), 1, CV_AA);
rectangle(frameToShow, annotationRectSX, Scalar(0, 0, 255), 1, CV_AA);
rectangle(frameToShow, annotationRectDX, Scalar(0, 0, 255), 1, CV_AA);
rectangle(frameToShow, annotationRectTOP, Scalar(0, 0, 255), 1, CV_AA);
rectangle(frameToShow, annotationRectBOTTOM, Scalar(0, 0, 255), 1, CV_AA);
if (drawRectangleOnTruth) {
rectangle(truthToShow, boundaryRect, Scalar(0, 255, 0), 1, CV_AA);
rectangle(truthToShow, annotationRectSX, Scalar(0, 0, 255), 1, CV_AA);
rectangle(truthToShow, annotationRectDX, Scalar(0, 0, 255), 1, CV_AA);
rectangle(truthToShow, annotationRectTOP, Scalar(0, 0, 255), 1, CV_AA);
rectangle(truthToShow, annotationRectBOTTOM, Scalar(0, 0, 255), 1, CV_AA);
}
// ############################################################# //
// Image show section
imshow("Webcam", frameToShow);
moveWindow("Webcam", Parameters::WINDOW_FIRST_COL, Parameters::WINDOW_FIRST_ROW);
imshow("Truth", truthToShow);
moveWindow("Truth", Parameters::WINDOW_SECOND_COL, Parameters::WINDOW_FIRST_ROW);
// ############################################################# //
// Wait key section
char key = waitKey(50);
if (key == Parameters::ESC_KEY) {
break;
} else if (key == 't') {
drawRectangleOnTruth = !drawRectangleOnTruth;
} else if (key == 's') {
// ############################################################# //
// Search section
// Channels vector (4 color spaces)
Mat channelsVector[12];
vector<string> channelLabels;
channelLabels.push_back("BGR_B");
channelLabels.push_back("BGR_G");
channelLabels.push_back("BGR_R");
channelLabels.push_back("HSV_H");
channelLabels.push_back("HSV_S");
channelLabels.push_back("HSV_V");
channelLabels.push_back("LAB_L");
channelLabels.push_back("LAB_A");
channelLabels.push_back("LAB_B");
channelLabels.push_back("YCRCB_Y");
channelLabels.push_back("YCRCB_CR");
channelLabels.push_back("YCRCB_CB");
// Blurred
Mat blurred;
blur(frame, blurred, Parameters::CALIBRATION_GAUSSIAN_BLUR_SIZE);
// Channel split data structure
vector<Mat> channelsSplit(3);
// BGR
split(blurred, channelsSplit);
channelsVector[Parameters::BGR_B] = channelsSplit[0].clone();
channelsVector[Parameters::BGR_G] = channelsSplit[1].clone();
channelsVector[Parameters::BGR_R] = channelsSplit[2].clone();
// HSV
Mat hsv;
cvtColor(blurred, hsv, CV_BGR2HSV);
split(hsv, channelsSplit);
channelsVector[Parameters::HSV_H] = channelsSplit[0].clone();
channelsVector[Parameters::HSV_S] = channelsSplit[1].clone();
channelsVector[Parameters::HSV_V] = channelsSplit[2].clone();
// Lab
Mat lab;
cvtColor(blurred, lab, CV_BGR2Lab);
split(lab, channelsSplit);
channelsVector[Parameters::LAB_L] = channelsSplit[0].clone();
channelsVector[Parameters::LAB_A] = channelsSplit[1].clone();
channelsVector[Parameters::LAB_B] = channelsSplit[2].clone();
// yCbCr
Mat yCbCr;
cvtColor(blurred, yCbCr, CV_BGR2YCrCb);
split(yCbCr, channelsSplit);
channelsVector[Parameters::YCRCB_Y] = channelsSplit[0].clone();
channelsVector[Parameters::YCRCB_CR] = channelsSplit[1].clone();
channelsVector[Parameters::YCRCB_CB] = channelsSplit[2].clone();
if (Parameters::CHANNEL_PREPROCESSING) {
// For each channel do some preprocessing
for (int i = 0; i < 12; i++) {
ImageProcessor::bottomHat(channelsVector[i], channelsVector[i],
Parameters::CALIBRATION_BOTTOM_HAT_MORPH_SE_SIZE);
medianBlur(channelsVector[i], channelsVector[i], Parameters::CALIBRATION_MEDIAN_BLUR_SIZE);
}
}
/*
* Channel choice (for optimization process)
* NOTE: value channels are discarded!
*/
vector<int> channelToOptimize;
channelToOptimize.push_back(Parameters::BGR_B);
channelToOptimize.push_back(Parameters::BGR_G);
channelToOptimize.push_back(Parameters::BGR_R);
channelToOptimize.push_back(Parameters::HSV_H);
channelToOptimize.push_back(Parameters::HSV_S);
channelToOptimize.push_back(Parameters::LAB_A);
channelToOptimize.push_back(Parameters::LAB_B);
channelToOptimize.push_back(Parameters::YCRCB_CR);
channelToOptimize.push_back(Parameters::YCRCB_CB);
// Results vector
vector<Parameters::ThresholdStructure> srVector;
// Search type selection
switch (Parameters::SELECTED_SEARCH) {
case Parameters::BRUTE_FORCE_SEARCH:
srVector = Utils::bruteForceSearch(truth, channelsVector, channelToOptimize, channelLabels);
break;
case Parameters::GREEDY_SEARCH:
srVector = Utils::greedySearch(truth, channelsVector, channelToOptimize, channelLabels);
break;
default:
break;
}
/*
* Searching for a good combination of channels (max Parameters::MAX_COMBINATION channels)
*/
vector<Parameters::ThresholdStructure> best_vector;
double best_value = std::numeric_limits<double>::min();
for (int k = 1; k <= Parameters::MAX_COMBINATION; k++) {
double best_k_value = std::numeric_limits<double>::min();
vector<Parameters::ThresholdStructure> best_k_vector;
cp::NextCombinationGenerator<Parameters::ThresholdStructure> combinationGen(srVector, k);
cp::NextCombinationGenerator<Parameters::ThresholdStructure>::iterator combIt;
for (combIt = combinationGen.begin(); combIt != combinationGen.end(); combIt++) {
// Vector with the current combination
vector<Parameters::ThresholdStructure> combination(*combIt);
double value = Utils::objFunction(truth, channelsVector, combination);
if (value > best_k_value) {
best_k_value = value;
best_k_vector = combination;
}
}
/*
* Is really necessary to select a more complicated combination?
* Aspiration criteria: choose a more complicated combination if it leads
* to an improvement proportional to the current best value
*/
if (best_k_value > best_value * Parameters::ASPIRATION_CRITERIA_FACTOR) {
best_value = best_k_value;
best_vector = best_k_vector;
}
}
// ############################################################# //
// Final results section
Mat thresholded;
Utils::getThresholdedImage(thresholded, channelsVector, best_vector);
Mat result;
Utils::getErrorImage(result, truth, thresholded);
destroyWindow("Webcam");
destroyWindow("Truth");
imshow("Final Thresh", thresholded);
moveWindow("Final Thresh", Parameters::WINDOW_FIRST_COL, Parameters::WINDOW_FIRST_ROW);
imshow("Error wrt Truth", result);
moveWindow("Error wrt Truth", Parameters::WINDOW_SECOND_COL, Parameters::WINDOW_FIRST_ROW);
pair<double, double> precisionRecall = Utils::getPrecisionRecall(truth, thresholded);
std::cout << "\nBest combination (max " << Parameters::MAX_COMBINATION
<< " channels):\n-------------------------------------------------\n";
cout << "F-Measure:\t" << best_value << "\n";
cout << "\tPrecision:\t" << precisionRecall.first << "\n";
cout << "\tRecall:\t\t" << precisionRecall.second << "\n";
cout << "Channels:\n";
for (unsigned int ch = 0; ch < best_vector.size(); ch++) {
cout << "\t" << channelLabels[best_vector[ch].channel] << "\t";
cout << "[" << best_vector[ch].thresh.first << ", " << best_vector[ch].thresh.second << "]\n";
}
// ############################################################# //
// Saving section
fs << "number" << (int) best_vector.size();
for (unsigned int ch = 0; ch < best_vector.size(); ch++) {
stringstream ss;
ss << "thresh" << "_" << ch;
fs << ss.str() << "{";
fs << "channel" << channelLabels[best_vector[ch].channel];
fs << "channel_id" << best_vector[ch].channel;
fs << "thresh" << "{" << "first" << best_vector[ch].thresh.first << "second"
<< best_vector[ch].thresh.second << "}";
fs << "}";
}
fs.release();
std::cout << "\nSaving" << "\n-------------------------------------------------\n";
std::cout << "Saved on yml file \"" << filename.str() << "\"\n\n";
std::cout << "Press a key to reset...\n";
std::cout << "Press Esc to quit...\n";
key = waitKey(0);
if (key == Parameters::ESC_KEY) {
break;
}
destroyWindow("Final Thresh");
destroyWindow("Error wrt Truth");
}
}
} else if (vm["subcommand"].as<string>().compare("register") == 0) {
//##############################################################################//
// REGISTRATION
//##############################################################################//
std::cout << "Register\n------------------------------------------" << "\n\n";
path documentsPath(documentsPathString);
path outputPath(outputPathString);
// Number of sets
std::cout << "> Number of sets:" << nSets << "\n\n";
if (nSets == 1) {
// Standard registration process for all the documents
path registeredPdfMapPath = outputPath / Parameters::REGISTERED_PDF_MAP_PATH;
path databasePath = outputPath / Parameters::DATABASE_PATH;
path outputImagesPath = outputPath / Parameters::IMAGES_PATH;
// Validates dataset output path
std::cout << "> Dataset output path validation" << std::endl;
FileManager::parentPathValidation(outputPath, outputImagesPath);
std::cout << std::endl;
// Loads the registeredPdfMap
FileManager::loadRegisteredPdfMap(Parameters::registeredPdfMap, registeredPdfMapPath);
std::cout << "> RegisteredPdfMap:" << "\n" << "\t" << "Path: " << registeredPdfMapPath << "\n" << "\t"
<< "Size: " << Parameters::registeredPdfMap.size() << "\n\n";
// Open a connection to the given database
DatabaseHandler::openDatabase(databasePath);
std::cout << "> Database:" << "\n" << "\t" << "Path: " << databasePath << "\n\n";
// Gets a list of pdf if pdfPath is a directory of pdf, gets a list with one pdf if pdfPath is a pdf
std::cout << "> Documents path:\t" << documentsPath << "\n\n";
list<string> pdfList;
FileManager::getPdfListFromPath(documentsPath, pdfList);
std::cout << "> # Pdf: " << pdfList.size() << "\n";
std::cout << "> Pdf List:\n";
// RegisteredPdfMap update flag
bool updateData = false;
// Iterate for all pdf in pdfList
list<string>::iterator pdfListIt;
for (pdfListIt = pdfList.begin(); pdfListIt != pdfList.end(); pdfListIt++) {
string pdfPath = *pdfListIt;
string pdfFileName = path(pdfPath).filename().string();
std::cout << "\t> " << pdfPath << "\n";
// Checks if the pdf was already registered (fileName is the key)
if (Parameters::registeredPdfMap.find(pdfFileName) == Parameters::registeredPdfMap.end()) {
// Pdf isn't already registered (and converted)
std::cout << "\t\tNot registered, conversion in progress..." << std::flush;
stringstream jpgPath;
jpgPath << outputImagesPath.string() << pdfFileName << ".jpg";
// Conversion
list<string> jpgList;
int numPages = FileManager::createImagesFromPdf(pdfPath, jpgPath.str(), jpgList);
if (numPages > 0) {
updateData = true;
std::cout << numPages << " pages converted\n";
bool errorDuringRegistration = false;
list<string>::iterator it = jpgList.begin();
int n = 0;
while (it != jpgList.end() && !errorDuringRegistration) {
std::cout << "\t\tRegistration for " << *it << " (" << (n + 1) << "/" << jpgList.size()
<< ")\n";
// ##################################
// PAGE REGISTRATION
// ##################################
// Get image features (centroids)
vector<Point> featurePoints;
Mat page = cv::imread(*it, CV_LOAD_IMAGE_GRAYSCALE);
ImageProcessor::getImageFeaturePoints(page, featurePoints);
string pageId = path(*it).filename().string();
FeaturesManager::registerFeatures(featurePoints, pageId);
it++;
n++;
}
if (!errorDuringRegistration) {
std::pair<string, string> record(pdfFileName, pdfPath);
// Updating the registeredPdfMap
Parameters::registeredPdfMap.insert(record);
}
} else {
std::cout << "an error occurred\n";
}
} else {
std::cout << "\t\tAlready registered" << "\n";
}
}
if (updateData) {
std::cout << "\n" << "Saving RegisteredPdfMap..." << std::flush;
// Saves the registeredPdfMap
FileManager::saveRegisteredPdfMap(Parameters::registeredPdfMap, registeredPdfMapPath);
std::cout << "DONE\n";
}
// Close database connection
DatabaseHandler::closeDatabase();
#ifdef DEBUG_FEATURES_MANAGER_DISCRETIZATION_STATISTICS
std::cout << "\n" << "> Max Affine invariant: " << Parameters::maxAffineInvariant << "\n";
std::cout << "> Invalid affine invariants: " << Parameters::invalidAffineInvariants << "\n";
std::cout << "> Affine invariant discretization statistics:" << "\n";
for (unsigned int i = 0; i < Parameters::K; i++) {
std::cout << "\t[" << i << "] = " << Parameters::DISCRETIZATION_STATISTICS[i] << "\n";
}
std::cout << "\n" << "> Sorting affine invariant vector (" << Parameters::affineInvariantVector.size()
<< " elements)..." << std::flush;
std::sort(Parameters::affineInvariantVector.begin(), Parameters::affineInvariantVector.end());
std::cout << "DONE\n";
std::cout << "> Optimal discretization vector ripartion (for these pdf):\n";
int step = Parameters::affineInvariantVector.size() / Parameters::K;
for (unsigned int i = 1; i < Parameters::K; i++) {
std::cout << "\t[" << (i * step) << "] = " << Parameters::affineInvariantVector[i * step] << "\n";
}
#endif
std::cout << "\n" << "> Terminated" << "\n";
} else {
//##############################################################################//
// REGISTRATION (WITH N_SETS>1)
//##############################################################################//
// srand initialization
unsigned int seed;
// Choose a fixed rand SEED or a new SEED based on time function
if (Parameters::USE_FIXED_RAND_SEED) {
seed = Parameters::FIXED_RAND_SEED;
} else {
seed = time(0);
}
srand(seed);
path outputAllImagesPath = outputPath / Parameters::IMAGES_PATH;
path convertedPdfMapPath = outputPath / Parameters::CONVERTED_PDF_MAP_PATH;
// Validates dataset output path
std::cout << "> Datasets output path validation" << std::endl;
FileManager::parentPathValidation(outputPath, outputAllImagesPath);
std::cout << std::endl;
// Loads the convertedPdfMap
FileManager::loadConvertedPdfMap(Parameters::convertedPdfMap, convertedPdfMapPath);
std::cout << "> ConvertedPdfMap:" << "\n" << "\t" << "Path: " << convertedPdfMapPath << "\n" << "\t"
<< "Size: " << Parameters::convertedPdfMap.size() << "\n\n";
// Gets a list of pdf if pdfPath is a directory of pdf, gets a list with one pdf if pdfPath is a pdf
std::cout << "> Documents path:\t" << documentsPath << "\n\n";
list<string> pdfList;
FileManager::getPdfListFromPath(documentsPath, pdfList);
std::cout << "> # Pdf: " << pdfList.size() << "\n";
std::cout << "> Pdf List:\n";
// Iterate for all pdf in pdfList and converts if not already converted
list<string>::iterator pdfListIt;
int pdfCounter = 1;
uint numPages = 0;
for (pdfListIt = pdfList.begin(); pdfListIt != pdfList.end(); pdfListIt++) {
string pdfPath = *pdfListIt;
string pdfFileName = path(pdfPath).filename().string();
// Checks if the pdf was already registered (fileName is the key)
typedef map<string, pair<string, int>>::const_iterator const_iterator;
const_iterator it = Parameters::convertedPdfMap.find(pdfFileName);
if (it == Parameters::convertedPdfMap.end()) {
// Pdf isn't already converted
std::cout << "\t> " << pdfPath << " conversion in progress (" << pdfCounter << "/" << pdfList.size()
<< ")\n";
stringstream jpgPath;
jpgPath << outputAllImagesPath.string() << pdfFileName << ".jpg";
// Conversion
list<string> jpgList;
int pages = FileManager::createImagesFromPdf(pdfPath, jpgPath.str(), jpgList);
numPages += pages;
if (pages > 0) {
// Update convertedPdfMap
std::pair<string, pair<string, int>> record(pdfFileName, make_pair(pdfPath, pages));
Parameters::convertedPdfMap.insert(record);
}
} else {
numPages += (it->second).second;
std::cout << "\t> " << pdfPath << " already converted (" << pdfCounter << "/" << pdfList.size()
<< ")\n";
}
pdfCounter++;
}
// Save convertedPdfMap
std::cout << "\n" << "> Saving convertedPdfMap..." << "\n";
FileManager::saveConvertedPdfMap(Parameters::convertedPdfMap, convertedPdfMapPath);
std::cout << "\n" << "> # Total pages: " << numPages << "\n\n";
try {
// Check if there are same pages converted but not in the converted list
vector<string> jpgVector;
FileManager::getJpgVectorFromPath(outputAllImagesPath, jpgVector);
if (numPages != jpgVector.size()) {
throw std::logic_error(
std::string(
"Number of pages in converted folder is inconsistent with the converted jpg list. Same pages may have been moved away from folder"));
}
// Check if pages converted are more then the nSets*nRetained
if (numPages < nSets * nRetained) {
throw std::logic_error(
std::string("Converted pages cannot be less than nSets*nRetained (")
+ boost::lexical_cast<string>(nSets * nRetained) + std::string(")."));
}
// Check if retained folder already exists
path outputRetainedImagesPath = outputPath / Parameters::RETAINED_IMAGES_PATH;
std::cout << "> Retained images path validation" << std::endl;
if (exists(outputRetainedImagesPath)) {
throw std::logic_error(
std::string("Retained images folder already exists. Please delete the folder."));
}
FileManager::parentPathValidation(outputPath, outputRetainedImagesPath);
// Check if some folder for sets already exists
int nIncrement = numPages / nSets;
std::cout << "\n> Sets output path validation" << std::endl << std::endl;
for (int i = 0; i < nSets; i++) {
int setSize = i * nIncrement + nIncrement;
path datasetPath = outputPath
/ std::string(Parameters::DATASET_PREFIX + boost::lexical_cast<string>(setSize));
if (exists(datasetPath)) {
throw std::logic_error(
std::string(datasetPath.string() + " already exists. Please delete the folder."));
}
}
// Choose nRetained elements and save to retained folder
vector<int> retainedIndexes;
vector<string> retainedImagesPath;
Utils::selectRandomDistinctIndexes(jpgVector.size(), retainedIndexes, nRetained);
sort(retainedIndexes.begin(), retainedIndexes.end(), greater<int>());
for (unsigned i = 0; i < retainedIndexes.size(); i++) {
int index = retainedIndexes.at(i);
string retainedJpgPath = jpgVector.at(index);
std::cout << "> Saving retained JPG #" << i + 1 << ": " << retainedJpgPath << "\n";
path imagePathFrom = retainedJpgPath;
path imagePathTo = outputRetainedImagesPath / path(retainedJpgPath).filename();
copy_file(imagePathFrom, imagePathTo, copy_option::overwrite_if_exists);
jpgVector.erase(jpgVector.begin() + index);
retainedImagesPath.push_back(retainedJpgPath);
}
// Create and register each set
for (int i = 0; i < nSets; i++) {
#ifdef DEBUG_FEATURES_MANAGER_DISCRETIZATION_STATISTICS
// Clear statistics vector
Parameters::affineInvariantVector.clear();
Parameters::maxAffineInvariant = 0;
Parameters::invalidAffineInvariants = 0;
#endif
int setSize = i * nIncrement + nIncrement;
std::cout << "\n> Registering set #" << i + 1 << " (" << setSize << " elements)" << std::endl;
// Create folders
path datasetPath = outputPath
/ std::string(Parameters::DATASET_PREFIX + boost::lexical_cast<string>(setSize));
path databasePath = datasetPath / Parameters::DATABASE_PATH;
path outputImagesPath = datasetPath / Parameters::IMAGES_PATH;
// Validates dataset output paths
std::cout << "> Dataset output paths validation" << std::endl;
FileManager::parentPathValidation(outputPath, datasetPath);
FileManager::parentPathValidation(datasetPath, outputImagesPath);
// Open a connection to the given database
DatabaseHandler::openDatabase(databasePath);
// Create vector of pages
int nToChoose = setSize - nRetained;
list<string> datasetImages;
for (unsigned j = 0; j < retainedImagesPath.size(); j++) {
path imagePathFrom = retainedImagesPath[j];
path imagePathTo = outputImagesPath / path(retainedImagesPath[j]).filename();
copy_file(imagePathFrom, imagePathTo, copy_option::overwrite_if_exists);
datasetImages.push_back(imagePathTo.string());
}
vector<int> choosenIndexes;
Utils::selectRandomDistinctIndexes(jpgVector.size(), choosenIndexes, nToChoose);
for (unsigned k = 0; k < choosenIndexes.size(); k++) {
int index = choosenIndexes.at(k);
string jpgPath = jpgVector.at(index);
path imagePathFrom = jpgPath;
path imagePathTo = outputImagesPath / path(jpgPath).filename();
copy_file(imagePathFrom, imagePathTo, copy_option::overwrite_if_exists);
datasetImages.push_back(imagePathTo.string());
}
// Register
bool errorDuringRegistration = false;
list<string>::iterator it = datasetImages.begin();
int n = 0;
while (it != datasetImages.end() && !errorDuringRegistration) {
std::cout << "\tRegistration for " << *it << " (" << (n + 1) << "/" << datasetImages.size()
<< ")\n";
// ##################################
// PAGE REGISTRATION
// ##################################
// Get image features (centroids)
vector<Point> featurePoints;
Mat page = cv::imread(*it, CV_LOAD_IMAGE_GRAYSCALE);
ImageProcessor::getImageFeaturePoints(page, featurePoints);
string pageId = path(*it).filename().string();
FeaturesManager::registerFeatures(featurePoints, pageId);
it++;
n++;
}
// Close database connection
DatabaseHandler::closeDatabase();
#ifdef DEBUG_FEATURES_MANAGER_DISCRETIZATION_STATISTICS
std::cout << "\n" << "> Max Affine invariant: " << Parameters::maxAffineInvariant << "\n";
std::cout << "> Invalid affine invariants: " << Parameters::invalidAffineInvariants << "\n";
std::cout << "> Affine invariant discretization statistics:" << "\n";
for (unsigned int i = 0; i < Parameters::K; i++) {
std::cout << "\t[" << i << "] = " << Parameters::DISCRETIZATION_STATISTICS[i] << "\n";
}
std::cout << "\n" << "> Sorting affine invariant vector ("
<< Parameters::affineInvariantVector.size() << " elements)..." << std::flush;
std::sort(Parameters::affineInvariantVector.begin(), Parameters::affineInvariantVector.end());
std::cout << "DONE\n";
std::cout << "> Optimal discretization vector ripartion (for these pdf):\n";
int step = Parameters::affineInvariantVector.size() / Parameters::K;
for (unsigned int i = 1; i < Parameters::K; i++) {
std::cout << "\t[" << (i * step) << "] = " << Parameters::affineInvariantVector[i * step]
<< "\n";
}
#endif
}
} catch (std::exception& e) {
std::cerr << e.what() << "\n";
return 0;
}
}
} else if (vm["subcommand"].as<string>().compare("annotate") == 0) {
XInitThreads();
//##############################################################################//
// ANNOTATION
//##############################################################################//
std::cout << "\nAnnotate\n------------------------------------------" << "\n";
path datasetPath(datasetPathString);
path pdfOutputPath(outputPathString);
path registeredPdfMapPath = datasetPath / Parameters::REGISTERED_PDF_MAP_PATH;
path databasePath = datasetPath / Parameters::DATABASE_PATH;
path masksPath = datasetPath / Parameters::MASKS_PATH;
path annotationsPath = datasetPath / Parameters::ANNOTATIONS_PATH;
// Validates masks path
std::cout << "> Masks path validation" << std::endl;
FileManager::parentPathValidation(datasetPath, masksPath);
std::cout << std::endl;
// Validates annotations path
std::cout << "> Annotations path validation" << std::endl;
FileManager::parentPathValidation(datasetPath, annotationsPath);
std::cout << std::endl;
// Validates pdf output path
std::cout << "> Pdf output path validation" << std::endl;
FileManager::pathValidation(pdfOutputPath);
std::cout << std::endl;
// Calibration file handle
if (calibrationSupplied) {
Parameters::ANNOTATION_COLOR_MODE = Parameters::ANNOTATION_COLOR_THRESHOLD_FILE_MODE;
} else {
Parameters::ANNOTATION_COLOR_MODE = Parameters::ANNOTATION_COLOR_FIXED_MODE;
}
if (Parameters::ANNOTATION_COLOR_MODE == Parameters::ANNOTATION_COLOR_THRESHOLD_FILE_MODE) {
vector<string> channelLabels;
channelLabels.push_back("BGR_B");
channelLabels.push_back("BGR_G");
channelLabels.push_back("BGR_R");
channelLabels.push_back("HSV_H");
channelLabels.push_back("HSV_S");
channelLabels.push_back("HSV_V");
channelLabels.push_back("LAB_L");
channelLabels.push_back("LAB_A");
channelLabels.push_back("LAB_B");
channelLabels.push_back("YCRCB_Y");
channelLabels.push_back("YCRCB_CR");
channelLabels.push_back("YCRCB_CB");
// Loads calibrated annotation thresholds
FileManager::loadAnnotationThresholds(calibrationPathString);
std::cout << "> Loaded calibrated annotation thresholds" << std::endl;
cout << "> Channels:\n";
for (unsigned int ch = 0; ch < Parameters::annotationThresholds.size(); ch++) {
cout << "\t" << channelLabels[Parameters::annotationThresholds[ch].channel] << "\t";
cout << "[" << Parameters::annotationThresholds[ch].thresh.first << ", "
<< Parameters::annotationThresholds[ch].thresh.second << "]\n";
}
} else {
std::cout << "> Fixed annotation thresholds (light blue)" << std::endl;
}
std::cout << std::endl;
// Loads the registeredPdfMap
FileManager::loadRegisteredPdfMap(Parameters::registeredPdfMap, registeredPdfMapPath);
std::cout << "> RegisteredPdfMap:" << "\n" << "\t" << "Path: " << registeredPdfMapPath << "\n" << "\t"
<< "Size: " << Parameters::registeredPdfMap.size() << "\n\n";
// Open a connection to the given database
DatabaseHandler::openDatabase(databasePath);
std::cout << "> Database:" << "\n" << "\t" << "Path: " << databasePath << "\n\n";
/*
* Inizializzazione macchina
* ####################################################################################
*/
StateMachine* sm = new StateMachine();
// Inizializzazione stati
PageDiscovering* pageDiscoveringState = new PageDiscovering(sm);
PageRetrieval* pageRetrievalState = new PageRetrieval(sm);
PageTracking* pageTrackingState = new PageTracking(sm);
PageError* pageErrorState = new PageError(sm);
PageAnnotation* pageAnnotationState = new PageAnnotation(sm);
PdfCreation* pdfCreationState = new PdfCreation(sm);
ExitState* exitState = new ExitState(sm);
// Inizializzazione stati iniziali e finali
sm->setInitialState(pageDiscoveringState);
sm->setFinalState(exitState);
// Inizializzazione transizioni
sm->addTransition(pageDiscoveringState, pageDiscoveringState, EvPageDiscoveringFail());
sm->addTransition(pageDiscoveringState, pageRetrievalState, EvPageDiscoveringSuccess());
sm->addTransition(pageRetrievalState, pageTrackingState, EvPageRetrievalDone());
sm->addTransition(pageRetrievalState, pageErrorState, EvPageRetrievalError());
sm->addTransition(pageTrackingState, pageTrackingState, EvPageTrackingSuccess());
sm->addTransition(pageTrackingState, pageAnnotationState, EvPageAnnotationStart());
sm->addTransition(pageTrackingState, pageErrorState, EvPageTrackingFailGenericError());
sm->addTransition(pageTrackingState, pageErrorState, EvPageTrackingFailHandOcclusion());
sm->addTransition(pageTrackingState, pageErrorState, EvPageTrackingAnnotationSaveError());
sm->addTransition(pageTrackingState, pdfCreationState, EvPdfCreationRequest());
sm->addTransition(pageAnnotationState, pageTrackingState, EvPageAnnotationEnd());
sm->addTransition(pdfCreationState, pageTrackingState, EvPdfCreationDone());
sm->addTransition(pageErrorState, pageDiscoveringState, EvErrorReset());
// Exit transitions
sm->addTransition(pageDiscoveringState, exitState, EvExit());
sm->addTransition(pageRetrievalState, exitState, EvExit());
sm->addTransition(pageTrackingState, exitState, EvExit());
sm->addTransition(pageAnnotationState, exitState, EvExit());
sm->addTransition(pdfCreationState, exitState, EvExit());
sm->addTransition(pageErrorState, exitState, EvExit());
// Set dataset path and pdf output path
sm->setDatasetPath(datasetPath);
sm->setPdfOutputPath(pdfOutputPath);
sm->initiate();
// Deleting objects
delete exitState;
delete pageTrackingState;
delete pageRetrievalState;
delete pageDiscoveringState;
delete pageErrorState;
delete pageAnnotationState;
delete pdfCreationState;
delete sm;
// Close database connection
DatabaseHandler::closeDatabase();
std::cout << "\n" << "> Terminated" << "\n";
} else if (vm["subcommand"].as<string>().compare("test") == 0) {
XInitThreads();
//##############################################################################//
// TEST
//##############################################################################//
#ifndef DEBUG_RETRIEVE_PAGE_PRINT_FINAL_STATISTICS
#define DEBUG_RETRIEVE_PAGE_PRINT_FINAL_STATISTICS
#endif
std::cout << "\nTest\n------------------------------------------" << "\n";
path datasetPath(datasetPathString);
path databasePath = datasetPath / Parameters::DATABASE_PATH;
// Open a connection to the given database
DatabaseHandler::openDatabase(databasePath);
std::cout << "> Database:" << "\n" << "\t" << "Path: " << databasePath << "\n\n";
/*
* Inizializzazione macchina
* ####################################################################################
*/
StateMachine* sm = new StateMachine();
// Inizializzazione stati
PageDiscovering* pageDiscoveringState = new PageDiscovering(sm);
PageRetrieval* pageRetrievalState = new PageRetrieval(sm);
ExitState* exitState = new ExitState(sm);
// Inizializzazione variabili di test
sm->setTest(true);
sm->setPageName(pageNameString);
// Inizializzazione stati iniziali e finali
sm->setInitialState(pageDiscoveringState);
sm->setFinalState(exitState);
// Inizializzazione transizioni
sm->addTransition(pageDiscoveringState, pageDiscoveringState, EvPageDiscoveringFail());
sm->addTransition(pageDiscoveringState, pageRetrievalState, EvPageDiscoveringSuccess());
sm->addTransition(pageRetrievalState, exitState, EvPageRetrievalDone());
// Exit transitions
sm->addTransition(pageDiscoveringState, exitState, EvExit());
sm->addTransition(pageRetrievalState, exitState, EvExit());
// Set dataset path and pdf output path
sm->setDatasetPath(datasetPath);
sm->initiate();
// Deleting objects
delete exitState;
delete pageRetrievalState;
delete pageDiscoveringState;
delete sm;
// Close database connection
DatabaseHandler::closeDatabase();
std::cout << "\n" << "> Terminated" << "\n";
}
return 0;
}
| 39.230627
| 142
| 0.647298
|
marcorighini
|
487d70365525e0524e8b956701e07282308b3b69
| 10,951
|
cc
|
C++
|
selfdrive/ui/qt/offroad/moc_networking.cc
|
leech2000/kona0813
|
c3e73e220b86614b82959712668408a48c33ebd3
|
[
"MIT"
] | 1
|
2022-03-23T13:52:40.000Z
|
2022-03-23T13:52:40.000Z
|
selfdrive/ui/qt/offroad/moc_networking.cc
|
leech2000/kona0813
|
c3e73e220b86614b82959712668408a48c33ebd3
|
[
"MIT"
] | null | null | null |
selfdrive/ui/qt/offroad/moc_networking.cc
|
leech2000/kona0813
|
c3e73e220b86614b82959712668408a48c33ebd3
|
[
"MIT"
] | 5
|
2022-03-24T16:18:47.000Z
|
2022-03-30T02:18:49.000Z
|
/****************************************************************************
** Meta object code from reading C++ file 'networking.h'
**
** Created by: The Qt Meta Object Compiler version 67 (Qt 5.12.8)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/
#include "networking.h"
#include <QtCore/qbytearray.h>
#include <QtCore/qmetatype.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'networking.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 67
#error "This file was generated using the moc from 5.12.8. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif
QT_BEGIN_MOC_NAMESPACE
QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
struct qt_meta_stringdata_WifiUI_t {
QByteArrayData data[6];
char stringdata0[43];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
qptrdiff(offsetof(qt_meta_stringdata_WifiUI_t, stringdata0) + ofs \
- idx * sizeof(QByteArrayData)) \
)
static const qt_meta_stringdata_WifiUI_t qt_meta_stringdata_WifiUI = {
{
QT_MOC_LITERAL(0, 0, 6), // "WifiUI"
QT_MOC_LITERAL(1, 7, 16), // "connectToNetwork"
QT_MOC_LITERAL(2, 24, 0), // ""
QT_MOC_LITERAL(3, 25, 7), // "Network"
QT_MOC_LITERAL(4, 33, 1), // "n"
QT_MOC_LITERAL(5, 35, 7) // "refresh"
},
"WifiUI\0connectToNetwork\0\0Network\0n\0"
"refresh"
};
#undef QT_MOC_LITERAL
static const uint qt_meta_data_WifiUI[] = {
// content:
8, // revision
0, // classname
0, 0, // classinfo
2, 14, // methods
0, 0, // properties
0, 0, // enums/sets
0, 0, // constructors
0, // flags
1, // signalCount
// signals: name, argc, parameters, tag, flags
1, 1, 24, 2, 0x06 /* Public */,
// slots: name, argc, parameters, tag, flags
5, 0, 27, 2, 0x0a /* Public */,
// signals: parameters
QMetaType::Void, 0x80000000 | 3, 4,
// slots: parameters
QMetaType::Void,
0 // eod
};
void WifiUI::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
auto *_t = static_cast<WifiUI *>(_o);
Q_UNUSED(_t)
switch (_id) {
case 0: _t->connectToNetwork((*reinterpret_cast< const Network(*)>(_a[1]))); break;
case 1: _t->refresh(); break;
default: ;
}
} else if (_c == QMetaObject::IndexOfMethod) {
int *result = reinterpret_cast<int *>(_a[0]);
{
using _t = void (WifiUI::*)(const Network & );
if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&WifiUI::connectToNetwork)) {
*result = 0;
return;
}
}
}
}
QT_INIT_METAOBJECT const QMetaObject WifiUI::staticMetaObject = { {
&QWidget::staticMetaObject,
qt_meta_stringdata_WifiUI.data,
qt_meta_data_WifiUI,
qt_static_metacall,
nullptr,
nullptr
} };
const QMetaObject *WifiUI::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *WifiUI::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_meta_stringdata_WifiUI.stringdata0))
return static_cast<void*>(this);
return QWidget::qt_metacast(_clname);
}
int WifiUI::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QWidget::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 2)
qt_static_metacall(this, _c, _id, _a);
_id -= 2;
} else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 2)
*reinterpret_cast<int*>(_a[0]) = -1;
_id -= 2;
}
return _id;
}
// SIGNAL 0
void WifiUI::connectToNetwork(const Network & _t1)
{
void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
struct qt_meta_stringdata_AdvancedNetworking_t {
QByteArrayData data[6];
char stringdata0[62];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
qptrdiff(offsetof(qt_meta_stringdata_AdvancedNetworking_t, stringdata0) + ofs \
- idx * sizeof(QByteArrayData)) \
)
static const qt_meta_stringdata_AdvancedNetworking_t qt_meta_stringdata_AdvancedNetworking = {
{
QT_MOC_LITERAL(0, 0, 18), // "AdvancedNetworking"
QT_MOC_LITERAL(1, 19, 9), // "backPress"
QT_MOC_LITERAL(2, 29, 0), // ""
QT_MOC_LITERAL(3, 30, 15), // "toggleTethering"
QT_MOC_LITERAL(4, 46, 7), // "enabled"
QT_MOC_LITERAL(5, 54, 7) // "refresh"
},
"AdvancedNetworking\0backPress\0\0"
"toggleTethering\0enabled\0refresh"
};
#undef QT_MOC_LITERAL
static const uint qt_meta_data_AdvancedNetworking[] = {
// content:
8, // revision
0, // classname
0, 0, // classinfo
3, 14, // methods
0, 0, // properties
0, 0, // enums/sets
0, 0, // constructors
0, // flags
1, // signalCount
// signals: name, argc, parameters, tag, flags
1, 0, 29, 2, 0x06 /* Public */,
// slots: name, argc, parameters, tag, flags
3, 1, 30, 2, 0x0a /* Public */,
5, 0, 33, 2, 0x0a /* Public */,
// signals: parameters
QMetaType::Void,
// slots: parameters
QMetaType::Void, QMetaType::Bool, 4,
QMetaType::Void,
0 // eod
};
void AdvancedNetworking::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
auto *_t = static_cast<AdvancedNetworking *>(_o);
Q_UNUSED(_t)
switch (_id) {
case 0: _t->backPress(); break;
case 1: _t->toggleTethering((*reinterpret_cast< bool(*)>(_a[1]))); break;
case 2: _t->refresh(); break;
default: ;
}
} else if (_c == QMetaObject::IndexOfMethod) {
int *result = reinterpret_cast<int *>(_a[0]);
{
using _t = void (AdvancedNetworking::*)();
if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&AdvancedNetworking::backPress)) {
*result = 0;
return;
}
}
}
}
QT_INIT_METAOBJECT const QMetaObject AdvancedNetworking::staticMetaObject = { {
&QWidget::staticMetaObject,
qt_meta_stringdata_AdvancedNetworking.data,
qt_meta_data_AdvancedNetworking,
qt_static_metacall,
nullptr,
nullptr
} };
const QMetaObject *AdvancedNetworking::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *AdvancedNetworking::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_meta_stringdata_AdvancedNetworking.stringdata0))
return static_cast<void*>(this);
return QWidget::qt_metacast(_clname);
}
int AdvancedNetworking::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QWidget::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 3)
qt_static_metacall(this, _c, _id, _a);
_id -= 3;
} else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 3)
*reinterpret_cast<int*>(_a[0]) = -1;
_id -= 3;
}
return _id;
}
// SIGNAL 0
void AdvancedNetworking::backPress()
{
QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}
struct qt_meta_stringdata_Networking_t {
QByteArrayData data[8];
char stringdata0[66];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
qptrdiff(offsetof(qt_meta_stringdata_Networking_t, stringdata0) + ofs \
- idx * sizeof(QByteArrayData)) \
)
static const qt_meta_stringdata_Networking_t qt_meta_stringdata_Networking = {
{
QT_MOC_LITERAL(0, 0, 10), // "Networking"
QT_MOC_LITERAL(1, 11, 7), // "refresh"
QT_MOC_LITERAL(2, 19, 0), // ""
QT_MOC_LITERAL(3, 20, 16), // "connectToNetwork"
QT_MOC_LITERAL(4, 37, 7), // "Network"
QT_MOC_LITERAL(5, 45, 1), // "n"
QT_MOC_LITERAL(6, 47, 13), // "wrongPassword"
QT_MOC_LITERAL(7, 61, 4) // "ssid"
},
"Networking\0refresh\0\0connectToNetwork\0"
"Network\0n\0wrongPassword\0ssid"
};
#undef QT_MOC_LITERAL
static const uint qt_meta_data_Networking[] = {
// content:
8, // revision
0, // classname
0, 0, // classinfo
3, 14, // methods
0, 0, // properties
0, 0, // enums/sets
0, 0, // constructors
0, // flags
0, // signalCount
// slots: name, argc, parameters, tag, flags
1, 0, 29, 2, 0x0a /* Public */,
3, 1, 30, 2, 0x08 /* Private */,
6, 1, 33, 2, 0x08 /* Private */,
// slots: parameters
QMetaType::Void,
QMetaType::Void, 0x80000000 | 4, 5,
QMetaType::Void, QMetaType::QString, 7,
0 // eod
};
void Networking::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
auto *_t = static_cast<Networking *>(_o);
Q_UNUSED(_t)
switch (_id) {
case 0: _t->refresh(); break;
case 1: _t->connectToNetwork((*reinterpret_cast< const Network(*)>(_a[1]))); break;
case 2: _t->wrongPassword((*reinterpret_cast< const QString(*)>(_a[1]))); break;
default: ;
}
}
}
QT_INIT_METAOBJECT const QMetaObject Networking::staticMetaObject = { {
&QFrame::staticMetaObject,
qt_meta_stringdata_Networking.data,
qt_meta_data_Networking,
qt_static_metacall,
nullptr,
nullptr
} };
const QMetaObject *Networking::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *Networking::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_meta_stringdata_Networking.stringdata0))
return static_cast<void*>(this);
return QFrame::qt_metacast(_clname);
}
int Networking::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QFrame::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 3)
qt_static_metacall(this, _c, _id, _a);
_id -= 3;
} else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 3)
*reinterpret_cast<int*>(_a[0]) = -1;
_id -= 3;
}
return _id;
}
QT_WARNING_POP
QT_END_MOC_NAMESPACE
| 29.438172
| 100
| 0.611816
|
leech2000
|
487e0dfee4d2acf3dc12089a338bb6849b6daecd
| 7,677
|
hpp
|
C++
|
include/dualsynth/vs_wrapper.hpp
|
msg7086/MiniDeen
|
0342ed55d8cf2b5cb4077ff206d4e5bbaac734fa
|
[
"MIT"
] | 6
|
2020-04-11T06:59:28.000Z
|
2021-07-20T14:31:01.000Z
|
include/dualsynth/vs_wrapper.hpp
|
HomeOfAviSynthPlusEvolution/neo_Gradient_Mask
|
d460f6070ece54e1a8fded93f9caacb718256ceb
|
[
"MIT"
] | 2
|
2020-05-31T23:48:16.000Z
|
2022-03-28T09:41:50.000Z
|
include/dualsynth/vs_wrapper.hpp
|
HomeOfAviSynthPlusEvolution/neo_TMedian
|
9b6a8931badeaa1ce7c1b692ddbf1f06620c0e93
|
[
"MIT"
] | 2
|
2020-08-15T03:40:50.000Z
|
2021-05-30T11:48:34.000Z
|
/*
* Copyright 2020 Xinyue Lu
*
* DualSynth wrapper - VapourSynth.
*
*/
#pragma once
namespace Plugin {
extern const char* Identifier;
extern const char* Namespace;
extern const char* Description;
}
namespace VSInterface {
const VSAPI * API;
struct VSInDelegator final : InDelegator {
const VSMap *_in;
const VSAPI *_vsapi;
int _err;
void Read(const char* name, int& output) override {
auto _default = output;
output = static_cast<int>(_vsapi->propGetInt(_in, name, 0, &_err));
if (_err) output = _default;
}
void Read(const char* name, int64_t& output) override {
auto _default = output;
output = _vsapi->propGetInt(_in, name, 0, &_err);
if (_err) output = _default;
}
void Read(const char* name, float& output) override {
auto _default = output;
output = static_cast<float>(_vsapi->propGetFloat(_in, name, 0, &_err));
if (_err) output = _default;
}
void Read(const char* name, double& output) override {
auto _default = output;
output = _vsapi->propGetFloat(_in, name, 0, &_err);
if (_err) output = _default;
}
void Read(const char* name, bool& output) override {
auto output_int = _vsapi->propGetInt(_in, name, 0, &_err);
if (!_err) output = output_int != 0;
}
void Read(const char* name, std::string& output) override {
auto output_str = _vsapi->propGetData(_in, name, 0, &_err);
if (!_err) output = output_str;
}
void Read(const char* name, std::vector<int>& output) override {
auto size = _vsapi->propNumElements(_in, name);
if (size < 0) return;
output.clear();
for (int i = 0; i < size; i++)
output.push_back(static_cast<int>(_vsapi->propGetInt(_in, name, i, &_err)));
}
void Read(const char* name, std::vector<int64_t>& output) override {
auto size = _vsapi->propNumElements(_in, name);
if (size < 0) return;
output.clear();
for (int i = 0; i < size; i++)
output.push_back(_vsapi->propGetInt(_in, name, i, &_err));
}
void Read(const char* name, std::vector<float>& output) override {
auto size = _vsapi->propNumElements(_in, name);
if (size < 0) return;
output.clear();
for (int i = 0; i < size; i++)
output.push_back(static_cast<float>(_vsapi->propGetFloat(_in, name, i, &_err)));
}
void Read(const char* name, std::vector<double>& output) override {
auto size = _vsapi->propNumElements(_in, name);
if (size < 0) return;
output.clear();
for (int i = 0; i < size; i++)
output.push_back(_vsapi->propGetFloat(_in, name, i, &_err));
}
void Read(const char* name, std::vector<bool>& output) override {
auto size = _vsapi->propNumElements(_in, name);
if (size < 0) return;
output.clear();
for (int i = 0; i < size; i++)
output.push_back(_vsapi->propGetInt(_in, name, i, &_err));
}
void Read(const char* name, void*& output) override {
output = reinterpret_cast<void *>(_vsapi->propGetNode(_in, name, 0, &_err));
}
void Free(void*& clip) override {
_vsapi->freeNode(reinterpret_cast<VSNodeRef *>(clip));
clip = nullptr;
}
VSInDelegator(const VSMap *in, const VSAPI *vsapi) : _in(in), _vsapi(vsapi) {}
};
struct VSFetchFrameFunctor final : FetchFrameFunctor {
VSNodeRef *_vs_clip;
VSCore *_core;
const VSAPI *_vsapi;
VSFrameContext *_frameCtx;
VSFetchFrameFunctor(VSNodeRef *clip, VSCore *core, const VSAPI *vsapi)
: _vs_clip(clip), _core(core), _vsapi(vsapi) {}
DSFrame operator()(int n) override {
return DSFrame(_vsapi->getFrameFilter(n, _vs_clip, _frameCtx), _core, _vsapi);
}
~VSFetchFrameFunctor() override {
_vsapi->freeNode(_vs_clip);
}
};
template<typename FilterType>
void VS_CC Initialize(VSMap *in, VSMap *out, void **instanceData, VSNode *node, VSCore *core, const VSAPI *vsapi) {
auto Data = reinterpret_cast<FilterType*>(*instanceData);
auto output_vi = Data->GetOutputVI();
vsapi->setVideoInfo(output_vi.ToVSVI(core, vsapi), 1, node);
}
template<typename FilterType>
void VS_CC Delete(void *instanceData, VSCore *core, const VSAPI *vsapi) {
auto filter = reinterpret_cast<FilterType*>(instanceData);
auto functor = reinterpret_cast<VSFetchFrameFunctor*>(filter->fetch_frame);
delete functor;
delete filter;
}
template<typename FilterType>
const VSFrameRef* VS_CC GetFrame(int n, int activationReason, void **instanceData, void **frameData, VSFrameContext *frameCtx, VSCore *core, const VSAPI *vsapi) {
auto filter = reinterpret_cast<FilterType*>(*instanceData);
auto functor = reinterpret_cast<VSFetchFrameFunctor*>(filter->fetch_frame);
if (functor)
functor->_frameCtx = frameCtx;
std::vector<int> ref_frames;
if (activationReason == VSActivationReason::arInitial) {
if (functor) {
ref_frames = filter->RequestReferenceFrames(n);
for (auto &&i : ref_frames)
vsapi->requestFrameFilter(i, functor->_vs_clip, frameCtx);
}
else {
std::unordered_map<int, DSFrame> in_frames;
in_frames[n] = DSFrame(core, vsapi);
auto vs_frame = (filter->GetFrame(n, in_frames).ToVSFrame());
return vs_frame;
}
}
else if (activationReason == VSActivationReason::arAllFramesReady) {
std::unordered_map<int, DSFrame> in_frames;
if (functor) {
ref_frames = filter->RequestReferenceFrames(n);
for (auto &&i : ref_frames)
in_frames[i] = DSFrame(vsapi->getFrameFilter(i, functor->_vs_clip, frameCtx), core, vsapi);
}
else
in_frames[n] = DSFrame(core, vsapi);
auto vs_frame = (filter->GetFrame(n, in_frames).ToVSFrame());
return vs_frame;
}
return nullptr;
}
template<typename FilterType>
void VS_CC Create(const VSMap *in, VSMap *out, void *userData, VSCore *core, const VSAPI *vsapi) {
auto filter = new FilterType{};
auto argument = VSInDelegator(in, vsapi);
try {
void* clip = nullptr;
VSFetchFrameFunctor* functor = nullptr;
DSVideoInfo input_vi;
try {
argument.Read("clip", clip);
if (clip) {
auto vs_clip = reinterpret_cast<VSNodeRef*>(clip);
functor = new VSFetchFrameFunctor(vs_clip, core, vsapi);
input_vi = DSVideoInfo(vsapi->getVideoInfo(vs_clip));
}
}
catch(const char *) { /* No clip, source filter */ }
filter->Initialize(&argument, input_vi, functor);
vsapi->createFilter(in, out, filter->VSName(), Initialize<FilterType>, GetFrame<FilterType>, Delete<FilterType>, filter->VSMode(), 0, filter, core);
}
catch(const char *err){
char msg_buff[256];
snprintf(msg_buff, 256, "%s: %s", filter->VSName(), err);
vsapi->setError(out, msg_buff);
delete filter;
}
}
template<typename FilterType>
void RegisterFilter(VSRegisterFunction registerFunc, VSPlugin* vsplugin) {
FilterType filter;
registerFunc(filter.VSName(), filter.VSParams().c_str(), Create<FilterType>, nullptr, vsplugin);
}
void RegisterPlugin(VSConfigPlugin configFunc, VSPlugin* vsplugin) {
configFunc(Plugin::Identifier, Plugin::Namespace, Plugin::Description, VAPOURSYNTH_API_VERSION, 1, vsplugin);
}
}
VS_EXTERNAL_API(void) VapourSynthPluginInit(VSConfigPlugin configFunc, VSRegisterFunction registerFunc, VSPlugin* vsplugin) {
VSInterface::RegisterPlugin(configFunc, vsplugin);
auto filters = RegisterVSFilters();
for (auto &&RegisterFilter : filters) {
RegisterFilter(registerFunc, vsplugin);
}
}
| 36.732057
| 164
| 0.650775
|
msg7086
|
487e2bcec9779c34207ff341520e18663564b64a
| 1,050
|
cpp
|
C++
|
getopt.cpp
|
AlexeyAkhunov/espresso
|
5c7a57ad6fde2fb3af46171ca1a5c78d250716e9
|
[
"MIT"
] | null | null | null |
getopt.cpp
|
AlexeyAkhunov/espresso
|
5c7a57ad6fde2fb3af46171ca1a5c78d250716e9
|
[
"MIT"
] | null | null | null |
getopt.cpp
|
AlexeyAkhunov/espresso
|
5c7a57ad6fde2fb3af46171ca1a5c78d250716e9
|
[
"MIT"
] | null | null | null |
#include <iostream>
/* File : getopt.c
Author : Henry Spencer, University of Toronto
Updated: 28 April 1984
Purpose: get option letter from argv.
*/
#define NullS ((char *) 0)
char *optarg; /* Global argument pointer. */
int optind = 0; /* Global argv index. */
int getopt(int argc, char* argv[], const char * optstring)
{
int c;
char *place;
static char *scan = NullS; /* Private scan pointer. */
optarg = NullS;
if (scan == NullS || *scan == '\0') {
if (optind == 0) optind++;
if (optind >= argc) return EOF;
place = argv[optind];
if (place[0] != '-' || place[1] == '\0') return EOF;
optind++;
if (place[1] == '-' && place[2] == '\0') return EOF;
scan = place+1;
}
c = *scan++;
place = strchr(optstring, c);
if (place == NullS || c == ':') {
fprintf(stderr, "%s: unknown option %c\n", argv[0], c);
return '?';
}
if (*++place == ':') {
if (*scan != '\0') {
optarg = scan, scan = NullS;
} else {
optarg = argv[optind], optind++;
}
}
return c;
}
| 23.333333
| 60
| 0.53619
|
AlexeyAkhunov
|
487edebbcb3d756bf076d8013b80fd33785d2ff4
| 3,550
|
cpp
|
C++
|
9/9.51/Date.cpp
|
kousikpramanik/C-_Primer_5th
|
e21fb665f04b26193fc13f9c2c263b782aea3f3c
|
[
"MIT"
] | null | null | null |
9/9.51/Date.cpp
|
kousikpramanik/C-_Primer_5th
|
e21fb665f04b26193fc13f9c2c263b782aea3f3c
|
[
"MIT"
] | 2
|
2020-08-15T17:33:00.000Z
|
2021-07-05T14:18:26.000Z
|
9/9.51/Date.cpp
|
kousikpramanik/C-_Primer_5th
|
e21fb665f04b26193fc13f9c2c263b782aea3f3c
|
[
"MIT"
] | 1
|
2020-08-15T17:24:54.000Z
|
2020-08-15T17:24:54.000Z
|
#include "Date.h"
#include <stdexcept>
#include <string>
#include <array>
#include <cctype>
Date::Date(unsigned a, unsigned b, unsigned c, unsigned style) : yyyy(a), mm(b), dd(c) {
switch (style) {
case 1: // dd/mm/yyyy
dd = a;
mm = b;
yyyy = c;
break;
case 2: // mm/dd/yyyy
dd = b;
mm = a;
yyyy = c;
break;
case 3: // dd/mm/yy
dd = a;
mm = b;
yyyy = 2000 + c;
break;
default: // yyyy/mm/dd
// handled by the constructor initialiser list
break;
}
if (!valid()) { throw std::invalid_argument("Invalid input."); }
}
// allowed formats -
// 1) <month name><delim><day><delim><year>
// 2) <month name><delim><year><delim><day> only when year > 31, otherwise assumes (1)
// 3) <day><delim><month name><delim><year>
// 4) <year><delim><month name><delim><day> only when year > 31, otherwise assumes (3)
// 5) <day><delim><month><delim><year>
// 6) <year><delim><month><delim><day> only when year > 31, otherwise assumes (5)
// delim must be one of " ", ", ", "/"
Date::Date(const std::string &inp) {
std::string str(inp);
for (auto &c : str) { c = std::tolower(c); }
constexpr std::array<char[4], 12> monName{"jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct",
"nov", "dec"};
constexpr char alphabet[]("qwertyuiopasdfghjklzxcvbnm");
decltype(str.size()) processed;
if (str.find_first_of(alphabet) == std::string::npos) { // numeric input
dd = std::stoul(str, &processed);
str.erase(0, processed);
erase_delim(str);
mm = std::stoul(str, &processed);
str.erase(0, processed);
erase_delim(str);
} else { // alphabetic input.
mm = 13; // invalid input if month name was not found in the loop
bool mfirst = false;
for (decltype(monName.size()) i = 0; i != 12; ++i) {
decltype(str.size()) pos = str.find(monName[i], 0);
if (pos != std::string::npos) {
if (pos == 0) { mfirst = true; }
mm = i + 1;
break;
}
}
if (mm == 13) { throw std::invalid_argument("Invalid month name."); }
if (mfirst) {
str.erase(0, str.find_first_not_of(alphabet));
erase_delim(str);
dd = std::stoul(str, &processed);
str.erase(0, processed);
erase_delim(str);
} else {
dd = std::stoul(str, &processed);
str.erase(0, processed);
erase_delim(str);
str.erase(0, str.find_first_not_of(alphabet));
erase_delim(str);
}
}
yyyy = std::stoul(str);
if (dd > 31) {
auto temp = dd;
dd = yyyy;
yyyy = temp;
}
if (!valid()) { throw std::invalid_argument("Invalid input."); }
}
bool Date::valid() {
constexpr std::array<int, 12> dInM{31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
if (mm == 0 || mm > 12) { return false; }
if (leap_year() && mm == 2 && dd != 0 && dd <= 29) { return true; }
return (dd != 0 && dd <= dInM[mm - 1]);
}
void Date::erase_delim(std::string &str) {
auto delim = str.at(0);
if (delim == ' ' || delim == '/') {
str.erase(0, 1);
} else if (delim == ',') {
str.erase(0, 2);
} else {
throw std::invalid_argument("Invalid delimiter.");
}
}
| 30.34188
| 115
| 0.498592
|
kousikpramanik
|
487f422835613b034bde30d95dae871b83bc2c2f
| 7,152
|
hpp
|
C++
|
include/UnityEngine/TestTools/TestRunner/GUI/SynchronousFilter.hpp
|
RedBrumbler/BeatSaber-Quest-Codegen
|
73dda50b5a3e51f10d86b766dcaa24b0c6226e25
|
[
"Unlicense"
] | null | null | null |
include/UnityEngine/TestTools/TestRunner/GUI/SynchronousFilter.hpp
|
RedBrumbler/BeatSaber-Quest-Codegen
|
73dda50b5a3e51f10d86b766dcaa24b0c6226e25
|
[
"Unlicense"
] | null | null | null |
include/UnityEngine/TestTools/TestRunner/GUI/SynchronousFilter.hpp
|
RedBrumbler/BeatSaber-Quest-Codegen
|
73dda50b5a3e51f10d86b766dcaa24b0c6226e25
|
[
"Unlicense"
] | null | null | null |
// Autogenerated from CppHeaderCreator
// Created by Sc2ad
// =========================================================================
#pragma once
// Begin includes
#include "beatsaber-hook/shared/utils/typedefs.h"
#include "beatsaber-hook/shared/utils/byref.hpp"
// Including type: NUnit.Framework.Interfaces.ITestFilter
#include "NUnit/Framework/Interfaces/ITestFilter.hpp"
#include "beatsaber-hook/shared/utils/il2cpp-utils-methods.hpp"
#include "beatsaber-hook/shared/utils/il2cpp-utils-properties.hpp"
#include "beatsaber-hook/shared/utils/il2cpp-utils-fields.hpp"
#include "beatsaber-hook/shared/utils/utils.h"
// Completed includes
// Begin forward declares
// Forward declaring namespace: UnityEngine::TestTools::TestRunner::GUI
namespace UnityEngine::TestTools::TestRunner::GUI {
}
// Forward declaring namespace: NUnit::Framework::Interfaces
namespace NUnit::Framework::Interfaces {
// Forward declaring type: TNode
class TNode;
// Forward declaring type: ITest
class ITest;
}
// Completed forward declares
// Type namespace: UnityEngine.TestTools.TestRunner.GUI
namespace UnityEngine::TestTools::TestRunner::GUI {
// Forward declaring type: SynchronousFilter
class SynchronousFilter;
}
#include "beatsaber-hook/shared/utils/il2cpp-type-check.hpp"
NEED_NO_BOX(::UnityEngine::TestTools::TestRunner::GUI::SynchronousFilter);
DEFINE_IL2CPP_ARG_TYPE(::UnityEngine::TestTools::TestRunner::GUI::SynchronousFilter*, "UnityEngine.TestTools.TestRunner.GUI", "SynchronousFilter");
// Type namespace: UnityEngine.TestTools.TestRunner.GUI
namespace UnityEngine::TestTools::TestRunner::GUI {
// Size: 0x10
#pragma pack(push, 1)
// Autogenerated type: UnityEngine.TestTools.TestRunner.GUI.SynchronousFilter
// [TokenAttribute] Offset: FFFFFFFF
class SynchronousFilter : public ::Il2CppObject/*, public ::NUnit::Framework::Interfaces::ITestFilter*/ {
public:
// Nested type: ::UnityEngine::TestTools::TestRunner::GUI::SynchronousFilter::$$c
class $$c;
// Creating interface conversion operator: operator ::NUnit::Framework::Interfaces::ITestFilter
operator ::NUnit::Framework::Interfaces::ITestFilter() noexcept {
return *reinterpret_cast<::NUnit::Framework::Interfaces::ITestFilter*>(this);
}
// public NUnit.Framework.Interfaces.TNode ToXml(System.Boolean recursive)
// Offset: 0x1950EC4
::NUnit::Framework::Interfaces::TNode* ToXml(bool recursive);
// public NUnit.Framework.Interfaces.TNode AddToXml(NUnit.Framework.Interfaces.TNode parentNode, System.Boolean recursive)
// Offset: 0x1950F2C
::NUnit::Framework::Interfaces::TNode* AddToXml(::NUnit::Framework::Interfaces::TNode* parentNode, bool recursive);
// public System.Boolean Pass(NUnit.Framework.Interfaces.ITest test)
// Offset: 0x1950F88
bool Pass(::NUnit::Framework::Interfaces::ITest* test);
// public System.Boolean IsExplicitMatch(NUnit.Framework.Interfaces.ITest test)
// Offset: 0x19517E0
bool IsExplicitMatch(::NUnit::Framework::Interfaces::ITest* test);
// public System.Void .ctor()
// Offset: 0x19509D4
// Implemented from: System.Object
// Base method: System.Void Object::.ctor()
template<::il2cpp_utils::CreationType creationType = ::il2cpp_utils::CreationType::Temporary>
static SynchronousFilter* New_ctor() {
static auto ___internal__logger = ::Logger::get().WithContext("::UnityEngine::TestTools::TestRunner::GUI::SynchronousFilter::.ctor");
return THROW_UNLESS((::il2cpp_utils::New<SynchronousFilter*, creationType>()));
}
}; // UnityEngine.TestTools.TestRunner.GUI.SynchronousFilter
#pragma pack(pop)
}
#include "beatsaber-hook/shared/utils/il2cpp-utils-methods.hpp"
// Writing MetadataGetter for method: UnityEngine::TestTools::TestRunner::GUI::SynchronousFilter::ToXml
// Il2CppName: ToXml
template<>
struct ::il2cpp_utils::il2cpp_type_check::MetadataGetter<static_cast<::NUnit::Framework::Interfaces::TNode* (UnityEngine::TestTools::TestRunner::GUI::SynchronousFilter::*)(bool)>(&UnityEngine::TestTools::TestRunner::GUI::SynchronousFilter::ToXml)> {
static const MethodInfo* get() {
static auto* recursive = &::il2cpp_utils::GetClassFromName("System", "Boolean")->byval_arg;
return ::il2cpp_utils::FindMethod(classof(UnityEngine::TestTools::TestRunner::GUI::SynchronousFilter*), "ToXml", std::vector<Il2CppClass*>(), ::std::vector<const Il2CppType*>{recursive});
}
};
// Writing MetadataGetter for method: UnityEngine::TestTools::TestRunner::GUI::SynchronousFilter::AddToXml
// Il2CppName: AddToXml
template<>
struct ::il2cpp_utils::il2cpp_type_check::MetadataGetter<static_cast<::NUnit::Framework::Interfaces::TNode* (UnityEngine::TestTools::TestRunner::GUI::SynchronousFilter::*)(::NUnit::Framework::Interfaces::TNode*, bool)>(&UnityEngine::TestTools::TestRunner::GUI::SynchronousFilter::AddToXml)> {
static const MethodInfo* get() {
static auto* parentNode = &::il2cpp_utils::GetClassFromName("NUnit.Framework.Interfaces", "TNode")->byval_arg;
static auto* recursive = &::il2cpp_utils::GetClassFromName("System", "Boolean")->byval_arg;
return ::il2cpp_utils::FindMethod(classof(UnityEngine::TestTools::TestRunner::GUI::SynchronousFilter*), "AddToXml", std::vector<Il2CppClass*>(), ::std::vector<const Il2CppType*>{parentNode, recursive});
}
};
// Writing MetadataGetter for method: UnityEngine::TestTools::TestRunner::GUI::SynchronousFilter::Pass
// Il2CppName: Pass
template<>
struct ::il2cpp_utils::il2cpp_type_check::MetadataGetter<static_cast<bool (UnityEngine::TestTools::TestRunner::GUI::SynchronousFilter::*)(::NUnit::Framework::Interfaces::ITest*)>(&UnityEngine::TestTools::TestRunner::GUI::SynchronousFilter::Pass)> {
static const MethodInfo* get() {
static auto* test = &::il2cpp_utils::GetClassFromName("NUnit.Framework.Interfaces", "ITest")->byval_arg;
return ::il2cpp_utils::FindMethod(classof(UnityEngine::TestTools::TestRunner::GUI::SynchronousFilter*), "Pass", std::vector<Il2CppClass*>(), ::std::vector<const Il2CppType*>{test});
}
};
// Writing MetadataGetter for method: UnityEngine::TestTools::TestRunner::GUI::SynchronousFilter::IsExplicitMatch
// Il2CppName: IsExplicitMatch
template<>
struct ::il2cpp_utils::il2cpp_type_check::MetadataGetter<static_cast<bool (UnityEngine::TestTools::TestRunner::GUI::SynchronousFilter::*)(::NUnit::Framework::Interfaces::ITest*)>(&UnityEngine::TestTools::TestRunner::GUI::SynchronousFilter::IsExplicitMatch)> {
static const MethodInfo* get() {
static auto* test = &::il2cpp_utils::GetClassFromName("NUnit.Framework.Interfaces", "ITest")->byval_arg;
return ::il2cpp_utils::FindMethod(classof(UnityEngine::TestTools::TestRunner::GUI::SynchronousFilter*), "IsExplicitMatch", std::vector<Il2CppClass*>(), ::std::vector<const Il2CppType*>{test});
}
};
// Writing MetadataGetter for method: UnityEngine::TestTools::TestRunner::GUI::SynchronousFilter::New_ctor
// Il2CppName: .ctor
// Cannot get method pointer of value based method overload from template for constructor!
// Try using FindMethod instead!
| 62.191304
| 293
| 0.739793
|
RedBrumbler
|
487f85e84100134aaad3a16abd62bef51302e3bd
| 5,137
|
cc
|
C++
|
google/cloud/pubsub/internal/default_subscription_batch_source.cc
|
orinem/google-cloud-cpp
|
c43f73e9abeb2b9d8a6e99f7d9750cba37f2f6b1
|
[
"Apache-2.0"
] | null | null | null |
google/cloud/pubsub/internal/default_subscription_batch_source.cc
|
orinem/google-cloud-cpp
|
c43f73e9abeb2b9d8a6e99f7d9750cba37f2f6b1
|
[
"Apache-2.0"
] | null | null | null |
google/cloud/pubsub/internal/default_subscription_batch_source.cc
|
orinem/google-cloud-cpp
|
c43f73e9abeb2b9d8a6e99f7d9750cba37f2f6b1
|
[
"Apache-2.0"
] | null | null | null |
// Copyright 2020 Google LLC
//
// 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 "google/cloud/pubsub/internal/default_subscription_batch_source.h"
#include "google/cloud/internal/async_retry_loop.h"
namespace google {
namespace cloud {
namespace pubsub_internal {
inline namespace GOOGLE_CLOUD_CPP_PUBSUB_NS {
using google::cloud::internal::AsyncRetryLoop;
using google::cloud::internal::Idempotency;
void DefaultSubscriptionBatchSource::Shutdown() {}
future<Status> DefaultSubscriptionBatchSource::AckMessage(
std::string const& ack_id, std::size_t) {
google::pubsub::v1::AcknowledgeRequest request;
request.set_subscription(subscription_full_name_);
request.add_ack_ids(ack_id);
auto& stub = stub_;
return AsyncRetryLoop(
retry_policy_->clone(), backoff_policy_->clone(),
Idempotency::kIdempotent, cq_,
[stub](google::cloud::CompletionQueue& cq,
std::unique_ptr<grpc::ClientContext> context,
google::pubsub::v1::AcknowledgeRequest const& request) {
return stub->AsyncAcknowledge(cq, std::move(context), request);
},
request, __func__);
}
future<Status> DefaultSubscriptionBatchSource::NackMessage(
std::string const& ack_id, std::size_t) {
google::pubsub::v1::ModifyAckDeadlineRequest request;
request.set_subscription(subscription_full_name_);
request.add_ack_ids(ack_id);
request.set_ack_deadline_seconds(0);
auto& stub = stub_;
return AsyncRetryLoop(
retry_policy_->clone(), backoff_policy_->clone(),
Idempotency::kIdempotent, cq_,
[stub](google::cloud::CompletionQueue& cq,
std::unique_ptr<grpc::ClientContext> context,
google::pubsub::v1::ModifyAckDeadlineRequest const& request) {
return stub->AsyncModifyAckDeadline(cq, std::move(context), request);
},
request, __func__);
}
future<Status> DefaultSubscriptionBatchSource::BulkNack(
std::vector<std::string> ack_ids, std::size_t) {
google::pubsub::v1::ModifyAckDeadlineRequest request;
request.set_subscription(subscription_full_name_);
for (auto& id : ack_ids) {
request.add_ack_ids(std::move(id));
}
request.set_ack_deadline_seconds(0);
auto& stub = stub_;
return AsyncRetryLoop(
retry_policy_->clone(), backoff_policy_->clone(),
Idempotency::kIdempotent, cq_,
[stub](google::cloud::CompletionQueue& cq,
std::unique_ptr<grpc::ClientContext> context,
google::pubsub::v1::ModifyAckDeadlineRequest const& request) {
return stub->AsyncModifyAckDeadline(cq, std::move(context), request);
},
request, __func__);
}
future<Status> DefaultSubscriptionBatchSource::ExtendLeases(
std::vector<std::string> ack_ids, std::chrono::seconds extension) {
google::pubsub::v1::ModifyAckDeadlineRequest request;
request.set_subscription(subscription_full_name_);
auto const actual_extension = [extension] {
// The service does not allow extending the deadline by more than 10
// minutes.
auto constexpr kMaximumAckDeadline = std::chrono::seconds(600);
if (extension < std::chrono::seconds(0)) return std::chrono::seconds(0);
if (extension > kMaximumAckDeadline) return kMaximumAckDeadline;
return extension;
}();
request.set_ack_deadline_seconds(
static_cast<std::int32_t>(actual_extension.count()));
for (auto& a : ack_ids) request.add_ack_ids(std::move(a));
auto& stub = stub_;
return AsyncRetryLoop(
retry_policy_->clone(), backoff_policy_->clone(),
Idempotency::kIdempotent, cq_,
[stub](google::cloud::CompletionQueue& cq,
std::unique_ptr<grpc::ClientContext> context,
google::pubsub::v1::ModifyAckDeadlineRequest const& request) {
return stub->AsyncModifyAckDeadline(cq, std::move(context), request);
},
request, __func__);
}
future<StatusOr<google::pubsub::v1::PullResponse>>
DefaultSubscriptionBatchSource::Pull(std::int32_t max_count) {
google::pubsub::v1::PullRequest request;
request.set_subscription(subscription_full_name_);
request.set_max_messages(max_count);
auto& stub = stub_;
return AsyncRetryLoop(
retry_policy_->clone(), backoff_policy_->clone(),
Idempotency::kIdempotent, cq_,
[stub](google::cloud::CompletionQueue& cq,
std::unique_ptr<grpc::ClientContext> context,
google::pubsub::v1::PullRequest const& request) {
return stub->AsyncPull(cq, std::move(context), request);
},
request, __func__);
}
} // namespace GOOGLE_CLOUD_CPP_PUBSUB_NS
} // namespace pubsub_internal
} // namespace cloud
} // namespace google
| 38.916667
| 77
| 0.716177
|
orinem
|
488164e55a149881e57cb01d4a1487931c57f1e4
| 291
|
hh
|
C++
|
src/Zynga/Framework/Dynamic/V1/Mocks/StaticClass.hh
|
chintan-j-patel/zynga-hacklang-framework
|
d9893b8873e3c8c7223772fd3c94d2531760172a
|
[
"MIT"
] | 19
|
2018-04-23T09:30:48.000Z
|
2022-03-06T21:35:18.000Z
|
src/Zynga/Framework/Dynamic/V1/Mocks/StaticClass.hh
|
chintan-j-patel/zynga-hacklang-framework
|
d9893b8873e3c8c7223772fd3c94d2531760172a
|
[
"MIT"
] | 22
|
2017-11-27T23:39:25.000Z
|
2019-08-09T08:56:57.000Z
|
src/Zynga/Framework/Dynamic/V1/Mocks/StaticClass.hh
|
chintan-j-patel/zynga-hacklang-framework
|
d9893b8873e3c8c7223772fd3c94d2531760172a
|
[
"MIT"
] | 28
|
2017-11-16T20:53:56.000Z
|
2021-01-04T11:13:17.000Z
|
<?hh // strict
namespace Zynga\Framework\Dynamic\V1\Mocks;
class StaticClass {
public static function testFunction(): bool {
return true;
}
public static function testFunctionWithParams(
string $param1,
int $param2,
): string {
return $param1.":".$param2;
}
}
| 15.315789
| 48
| 0.666667
|
chintan-j-patel
|
4888983725aab70b59e29dcc1ff408874f01b402
| 1,227
|
cpp
|
C++
|
Game/Source/Crate.cpp
|
KuronoaScarlet/ProjectII
|
5038d4366f39f26ec70cbebaf06d72e7c83e52a3
|
[
"MIT"
] | null | null | null |
Game/Source/Crate.cpp
|
KuronoaScarlet/ProjectII
|
5038d4366f39f26ec70cbebaf06d72e7c83e52a3
|
[
"MIT"
] | 1
|
2021-02-25T11:10:15.000Z
|
2021-04-18T16:48:04.000Z
|
Game/Source/Crate.cpp
|
KuronoaScarlet/ProjectII
|
5038d4366f39f26ec70cbebaf06d72e7c83e52a3
|
[
"MIT"
] | null | null | null |
#include "Crate.h"
#include "App.h"
#include "Render.h"
#include "Collisions.h"
#include "Collider.h"
#include "FadeToBlack.h"
#include "Scene1.h"
#include "Title.h"
#include "Map.h"
#include "Audio.h"
#include "EntityManager.h"
#include "Fonts.h"
#include "Defs.h"
#include "DialogSystem.h"
Crate::Crate(Module* listener, fPoint position, SDL_Texture* texture, Type type) : Entity(listener, position, texture, type)
{
idleAnimation.loop = true;
idleAnimation.PushBack({ 797,150, 28, 39 });
currentAnimation = &idleAnimation;
currentMoodAnimation = &moodAnimation;
collider = app->collisions->AddCollider(SDL_Rect({ (int)position.x, (int)position.y, 30, 46 }), Collider::Type::NPC, listener);
}
bool Crate::Start()
{
return true;
}
bool Crate::Update(float dt)
{
currentAnimation->Update();
currentMoodAnimation->Update();
return true;
}
bool Crate::Draw()
{
SDL_Rect rect = currentAnimation->GetCurrentFrame();
app->render->DrawTexture(texture, position.x, position.y, &rect);
return true;
}
bool Crate::Interaction()
{
app->sceneManager->crate = true;
pendingToDelete = true;
collider->pendingToDelete = true;
return true;
}
void Crate::Collision(Collider* coll)
{
}
void Crate::CleanUp()
{
}
| 18.044118
| 128
| 0.713121
|
KuronoaScarlet
|
489b33ab5348de67e5166d8f5f173ec3f5272b21
| 3,651
|
cpp
|
C++
|
Util/FileSearcher.cpp
|
danzimm/zld
|
3b0b1f1511d7a91c2ec89626be6ef3e99494c395
|
[
"MIT"
] | null | null | null |
Util/FileSearcher.cpp
|
danzimm/zld
|
3b0b1f1511d7a91c2ec89626be6ef3e99494c395
|
[
"MIT"
] | null | null | null |
Util/FileSearcher.cpp
|
danzimm/zld
|
3b0b1f1511d7a91c2ec89626be6ef3e99494c395
|
[
"MIT"
] | null | null | null |
// Copyright (c) 2020 Daniel Zimmerman
#include "Util/FileSearcher.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/Path.h"
namespace llvm {
namespace ald {
namespace {
PathList processSDKPrefixes(const std::vector<std::string> &SDKPrefixes,
const std::unique_ptr<Path> &Cwd) {
PathList RV;
if (!SDKPrefixes.empty()) {
for (const std::string &Prefix : SDKPrefixes) {
RV.emplace_back(Prefix);
auto &ProcessedPrefix = RV.back();
if (Cwd != nullptr) {
sys::fs::make_absolute(*Cwd, ProcessedPrefix);
} else {
sys::fs::make_absolute(ProcessedPrefix);
}
if (ProcessedPrefix.back() == '/') {
ProcessedPrefix.pop_back();
}
}
} else {
RV.push_back(Path(""));
}
return RV;
}
} // namespace
SearchPath::SearchPath(const std::vector<std::string> &SDKPrefixes,
const std::vector<std::string> &Paths,
const SmallVector<StringRef, 2> &DefaultPaths,
std::unique_ptr<Path> Cwd)
: SDKPrefixes_(processSDKPrefixes(SDKPrefixes, Cwd)) {
if (Cwd == nullptr) {
sys::fs::current_path(Cwd_);
} else {
Cwd_.assign(*Cwd);
}
if (Cwd_.back() != '/') {
Cwd_.push_back('/');
}
for (const std::string &Path : Paths) {
Paths_.push_back(Path);
if (Path.front() == '/') {
NumAbsolute_ += 1;
}
}
for (StringRef Path : DefaultPaths) {
Paths_.push_back(Path.str());
if (Path.front() == '/') {
NumAbsolute_ += 1;
}
}
}
namespace details {
namespace {
class FileNotFoundInSearchPath : public ErrorInfo<FileNotFoundInSearchPath> {
public:
static char ID;
SmallString<256> File;
SmallVector<SmallString<256>, 8> Paths;
FileNotFoundInSearchPath(Twine Filename, SmallVector<SmallString<256>, 8> PS)
: File(Filename.str()), Paths(std::move(PS)) {}
void log(raw_ostream &OS) const override {
OS << File << " not found in { ";
if (!Paths.empty()) {
auto Iter = Paths.begin();
auto End = Paths.end();
OS << *Iter++;
while (Iter != End) {
OS << ", " << *Iter++;
}
OS << " ";
}
OS << "}";
}
std::error_code convertToErrorCode() const override {
llvm_unreachable("Converting FileNotFoundInSearchPath to error_code"
" not supported");
}
};
char FileNotFoundInSearchPath::ID;
} // namespace
PathList FileSearcherImpl::getAllPaths() const {
PathList RV;
RV.reserve(SearchPath_.size());
SearchPath_.visit([&RV](const Twine &File) {
RV.emplace_back();
File.toVector(RV.back());
return false;
});
return RV;
}
Expected<Path> FileSearcherImpl::searchInternal(StringRef File) const {
Path RV;
auto Visitor = [&](const Twine &Dir) -> bool {
return searchForFileInDirectory(File, Dir, RV) && validatePath(RV);
};
if (SearchPath_.visit(Visitor)) {
return std::move(RV);
}
return make_error<FileNotFoundInSearchPath>(File, getAllPaths());
}
bool FileSearcherImpl::searchForFileInDirectory(StringRef File,
const Twine &Dir,
Path &Result) {
Result.clear();
Dir.toVector(Result);
sys::path::append(Result, File);
if (!sys::fs::exists(Result)) {
return false;
}
return true;
}
bool FileSearcherImpl::validatePath(StringRef File) const {
bool RV = false;
if (auto FD = sys::fs::openNativeFileForRead(File)) {
RV = validateFile(*FD);
sys::fs::closeFile(*FD);
}
return RV;
}
} // end namespace details
} // end namespace ald
} // end namespace llvm
| 23.862745
| 79
| 0.599288
|
danzimm
|
489b64cd17512088720803ddd1993fd6bfbcef25
| 495
|
cpp
|
C++
|
02. Bit Manipulation/05 One Odd Occurring/Bonus Question.cpp
|
VivekYadav105/Data-Structures-and-Algorithms
|
7287912da8068c9124e0bb89c93c4d52aa48c51f
|
[
"MIT"
] | 190
|
2021-02-10T17:01:01.000Z
|
2022-03-20T00:21:43.000Z
|
02. Bit Manipulation/05 One Odd Occurring/Bonus Question.cpp
|
VivekYadav105/Data-Structures-and-Algorithms
|
7287912da8068c9124e0bb89c93c4d52aa48c51f
|
[
"MIT"
] | null | null | null |
02. Bit Manipulation/05 One Odd Occurring/Bonus Question.cpp
|
VivekYadav105/Data-Structures-and-Algorithms
|
7287912da8068c9124e0bb89c93c4d52aa48c51f
|
[
"MIT"
] | 27
|
2021-03-26T11:35:15.000Z
|
2022-03-06T07:34:54.000Z
|
#include<bits/stdc++.h>
using namespace std;
//find the element which is missing from the range 1 to n
//trick 1 : xor of same numbers gives zero
//trick 2 : xor of zero with any number returns original number
int missing(int a[], int n)//time comp. O(n)
{
int X = 0;
for (int i = 1; i <= n; i++)
{
X = X ^ i;
}
for (int i = 0; i < n - 1; i++)
{
X = X ^ a[i];
}
return X;
}
int main()
{
int a[] = {1, 2, 3, 5, 6, 7, 8};
int n = 8;
cout << missing(a, n) << endl;
return 0;
}
| 15.967742
| 63
| 0.553535
|
VivekYadav105
|
48ae54bc80180d3096abb3c3f70a1040c550eb86
| 346
|
cpp
|
C++
|
UOJ/147/make.cpp
|
sjj118/OI-Code
|
964ea6e799d14010f305c7e4aee269d860a781f7
|
[
"MIT"
] | null | null | null |
UOJ/147/make.cpp
|
sjj118/OI-Code
|
964ea6e799d14010f305c7e4aee269d860a781f7
|
[
"MIT"
] | null | null | null |
UOJ/147/make.cpp
|
sjj118/OI-Code
|
964ea6e799d14010f305c7e4aee269d860a781f7
|
[
"MIT"
] | null | null | null |
#include<bits/stdc++.h>
using namespace std;
int T=4,n=23;
int cnt[15];
int main(){
srand(time(0));freopen("code.in","w",stdout);
printf("%d %d\n",T,n);
while(T--){
memset(cnt,0,sizeof(cnt));
for(int i=1;i<=n;++i){
int t=rand()%14;
while(!(t&&cnt[t]<=4||cnt[t]<=2))t=rand()%14;
printf("%d %d\n",t,rand()%4+1);
}
}
return 0;
}
| 19.222222
| 48
| 0.546243
|
sjj118
|
48b637bbaa2258a7eaa7656c6e69e947ba61cfb3
| 4,750
|
cpp
|
C++
|
provant_simulator_utils/provant_simulator_sdf_parser/src/sdf_parser.cpp
|
Guiraffo/ProVANT_Simulator
|
ef2260204b13f39a9f83ad2ab88a9552a0699bff
|
[
"MIT"
] | null | null | null |
provant_simulator_utils/provant_simulator_sdf_parser/src/sdf_parser.cpp
|
Guiraffo/ProVANT_Simulator
|
ef2260204b13f39a9f83ad2ab88a9552a0699bff
|
[
"MIT"
] | null | null | null |
provant_simulator_utils/provant_simulator_sdf_parser/src/sdf_parser.cpp
|
Guiraffo/ProVANT_Simulator
|
ef2260204b13f39a9f83ad2ab88a9552a0699bff
|
[
"MIT"
] | null | null | null |
/*
* This file is part of the ProVANT simulator project.
* Licensed under the terms of the MIT open source license. More details at
* https://github.com/Guiraffo/ProVANT-Simulator/blob/master/LICENSE.md
*/
/**
* @file sdf_parser.cpp
* @brief This file contains the implementation of the SDFParser class.
*
* @author Júnio Eduardo de Morais Aquino
*/
#include "provant_simulator_sdf_parser/sdf_parser.h"
#include <provant_simulator_parser_utils/type_conversion.h>
SDFParser::SDFParser(sdf::ElementPtr sdf) : _sdf(sdf)
{
}
SDFParser::~SDFParser()
{
}
sdf::ElementPtr SDFParser::GetElementPtr() const
{
return _sdf;
}
bool SDFParser::HasAttribute(const std::string& name) const
{
return _sdf->HasAttribute(name);
}
bool SDFParser::HasElement(const std::string& name) const
{
return _sdf->HasElement(name);
}
SDFStatus SDFParser::GetAttributeValue(const std::string& name, gsl::not_null<std::string*> value) const noexcept
{
value->clear();
if (HasAttribute(name))
{
(*value) = _sdf->GetAttribute(name)->GetAsString();
return OkStatus();
}
else
{
return AttributeNotFoundError(name);
}
}
std::string SDFParser::GetAttributeValue(const std::string& name) const
{
if (!HasAttribute(name))
{
throw AttributeNotFoundError(name);
}
return _sdf->GetAttribute(name)->GetAsString();
}
SDFStatus SDFParser::GetElementText(const std::string& name, gsl::not_null<std::string*> value) const noexcept
{
value->clear();
if (HasElement(name))
{
(*value) = _sdf->GetElement(name)->GetValue()->GetAsString();
return OkStatus();
}
else
{
return ElementNotFoundError(name);
}
}
std::string SDFParser::GetElementText(const std::string& name) const
{
if (!HasElement(name))
{
throw ElementNotFoundError(name);
}
return _sdf->GetElement(name)->GetValue()->GetAsString();
}
bool SDFParser::GetElementBool(const std::string& name) const
{
try
{
std::string strValue = GetElementText(name);
try
{
return ParseBool(strValue);
}
catch (const std::exception& e)
{
throw ConversionError(name, strValue, "bool");
}
}
catch (const SDFStatus& e)
{
throw e;
}
}
int SDFParser::GetElementInt(const std::string& name) const
{
try
{
std::string strValue = GetElementText(name);
try
{
return ParseInt(strValue);
}
catch (const std::exception& e)
{
throw ConversionError(name, strValue, "int");
}
}
catch (const SDFStatus& e)
{
throw e;
}
}
unsigned int SDFParser::GetElementUnsignedInt(const std::string& name) const
{
try
{
std::string strValue = GetElementText(name);
try
{
return ParseUnsignedInt(strValue);
}
catch (const std::exception& e)
{
throw ConversionError(name, strValue, "unsigned int");
}
}
catch (const SDFStatus& e)
{
throw e;
}
}
float SDFParser::GetElementFloat(const std::string& name) const
{
try
{
std::string strValue = GetElementText(name);
try
{
return ParseFloat(strValue);
}
catch (const std::exception& e)
{
throw ConversionError(name, strValue, "float");
}
}
catch (const SDFStatus& e)
{
throw e;
}
}
double SDFParser::GetElementDouble(const std::string& name) const
{
try
{
std::string strValue = GetElementText(name);
try
{
return ParseDouble(strValue);
}
catch (const std::exception& e)
{
throw ConversionError(name, strValue, "double");
}
}
catch (const SDFStatus& e)
{
throw e;
}
}
SDFStatus SDFParser::GetElementBool(const std::string& name, gsl::not_null<bool*> value) const noexcept
{
try
{
*value = GetElementBool(name);
return OkStatus();
}
catch (const SDFStatus& e)
{
return e;
}
}
SDFStatus SDFParser::GetElementInt(const std::string& name, gsl::not_null<int*> value) const noexcept
{
try
{
*value = GetElementInt(name);
return OkStatus();
}
catch (const SDFStatus& e)
{
return e;
}
}
SDFStatus SDFParser::GetElementUnsignedInt(const std::string& name, gsl::not_null<unsigned int*> value) const noexcept
{
try
{
*value = GetElementUnsignedInt(name);
return OkStatus();
}
catch (const SDFStatus& e)
{
return e;
}
}
SDFStatus SDFParser::GetElementFloat(const std::string& name, gsl::not_null<float*> value) const noexcept
{
try
{
*value = GetElementFloat(name);
return OkStatus();
}
catch (const SDFStatus& e)
{
return e;
}
}
SDFStatus SDFParser::GetElementDouble(const std::string& name, gsl::not_null<double*> value) const noexcept
{
try
{
*value = GetElementDouble(name);
return OkStatus();
}
catch (const SDFStatus& e)
{
return e;
}
}
| 19
| 118
| 0.656842
|
Guiraffo
|
48b7e0c4de443585c7baac70d42937cd33fc9edc
| 1,102
|
cpp
|
C++
|
src/audio/EmuEqualizer.cpp
|
AlexanderBrevig/emu-jukebox
|
131f73934e5aea4d587817b999e6869fa692d0ba
|
[
"BSD-2-Clause"
] | 9
|
2019-03-09T16:55:00.000Z
|
2022-02-08T21:24:59.000Z
|
src/audio/EmuEqualizer.cpp
|
AlexanderBrevig/emu-jukebox
|
131f73934e5aea4d587817b999e6869fa692d0ba
|
[
"BSD-2-Clause"
] | 69
|
2019-03-09T21:54:12.000Z
|
2021-12-26T09:30:20.000Z
|
src/audio/EmuEqualizer.cpp
|
AlexanderBrevig/emu-jukebox
|
131f73934e5aea4d587817b999e6869fa692d0ba
|
[
"BSD-2-Clause"
] | 2
|
2019-03-11T19:03:54.000Z
|
2019-04-18T19:55:51.000Z
|
//
// Created by robin on 16.01.19.
//
#include "EmuEqualizer.h"
ebox::EmuEqualizer::EmuEqualizer()
{
}
ebox::EmuEqualizer::EmuEqualizer(Music_Emu *emu)
{
initialize(emu);
}
void ebox::EmuEqualizer::draw()
{
if(m_emu != nullptr)
{
float treble = static_cast<float>(m_equalizer.treble);
float bass = static_cast<float>(m_equalizer.bass);
if (ImGui::SliderFloat("Treble", &treble, -50, 10, "%.0f")) m_emu->set_equalizer(m_equalizer);
if (ImGui::SliderFloat("Bass", &bass, 16000, 1, "%.0f")) m_emu->set_equalizer(m_equalizer);
m_equalizer.treble = treble;
m_equalizer.bass = bass;
}
//ImGui::Text("-50.0 = muffled, 0 = flat, +5.0 = extra-crisp");
//if(ImGui::InputDouble("Treble", &m_equalizer.treble, 1, 5)) m_emu->set_equalizer(m_equalizer);
//ImGui::Text("1 = full bass, 90 = average, 16000 = almost no bass");
//if(ImGui::InputDouble("Bass", &m_equalizer.bass, 1, 5)) m_emu->set_equalizer(m_equalizer);
}
void ebox::EmuEqualizer::initialize(Music_Emu *emu)
{
m_emu = emu;
m_equalizer = emu->equalizer();
}
| 27.55
| 102
| 0.642468
|
AlexanderBrevig
|
48be8f47fa1fcffc64d24d04606e30167ca2a31b
| 6,220
|
cpp
|
C++
|
src/wire/libevent_callbacks.cpp
|
xhad1234/peloton
|
60dea12ed528bc8873b1c43d1eca841a5d76ee44
|
[
"Apache-2.0"
] | 2
|
2017-07-24T12:25:58.000Z
|
2022-03-17T11:43:42.000Z
|
src/wire/libevent_callbacks.cpp
|
xhad1234/peloton
|
60dea12ed528bc8873b1c43d1eca841a5d76ee44
|
[
"Apache-2.0"
] | 2
|
2016-10-01T00:36:16.000Z
|
2016-11-05T23:40:07.000Z
|
src/wire/libevent_callbacks.cpp
|
xhad1234/peloton
|
60dea12ed528bc8873b1c43d1eca841a5d76ee44
|
[
"Apache-2.0"
] | 3
|
2016-09-24T01:22:30.000Z
|
2019-01-09T16:17:25.000Z
|
//===----------------------------------------------------------------------===//
//
// Peloton
//
// libevent_callbacks.cpp
//
// Implements Libevent callbacks for the protocol and their helpers
//
// Identification: src/wire/libevent_callbacks.cpp
//
// Copyright (c) 2015-16, Carnegie Mellon University Database Group
//
//===----------------------------------------------------------------------===//
#include <unistd.h>
#include "wire/libevent_server.h"
#include "common/macros.h"
namespace peloton {
namespace wire {
void WorkerHandleNewConn(evutil_socket_t new_conn_recv_fd,
UNUSED_ATTRIBUTE short ev_flags, void *arg) {
// buffer used to receive messages from the main thread
char m_buf[1];
std::shared_ptr<NewConnQueueItem> item;
LibeventSocket *conn;
LibeventWorkerThread *thread = static_cast<LibeventWorkerThread *>(arg);
// pipe fds should match
PL_ASSERT(new_conn_recv_fd == thread->new_conn_receive_fd);
// read the operation that needs to be performed
if (read(new_conn_recv_fd, m_buf, 1) != 1) {
LOG_ERROR("Can't read from the libevent pipe");
return;
}
switch (m_buf[0]) {
/* new connection case */
case 'c': {
// fetch the new connection fd from the queue
thread->new_conn_queue.Dequeue(item);
conn = LibeventServer::GetConn(item->new_conn_fd);
if (conn == nullptr) {
LOG_DEBUG("Creating new socket fd:%d", item->new_conn_fd);
/* create a new connection object */
LibeventServer::CreateNewConn(item->new_conn_fd, item->event_flags,
static_cast<LibeventThread *>(thread),
CONN_READ);
} else {
LOG_DEBUG("Reusing socket fd:%d", item->new_conn_fd);
/* otherwise reset and reuse the existing conn object */
conn->Reset();
conn->Init(item->event_flags, static_cast<LibeventThread *>(thread),
CONN_READ);
}
break;
}
default:
LOG_ERROR("Unexpected message. Shouldn't reach here");
}
}
void EventHandler(UNUSED_ATTRIBUTE evutil_socket_t connfd, short ev_flags, void *arg) {
LOG_TRACE("Event callback fired for connfd: %d", connfd);
LibeventSocket *conn = static_cast<LibeventSocket *>(arg);
PL_ASSERT(conn != nullptr);
conn->event_flags = ev_flags;
PL_ASSERT(connfd == conn->sock_fd);
StateMachine(conn);
}
void StateMachine(LibeventSocket *conn) {
bool done = false;
while (done == false) {
switch (conn->state) {
case CONN_LISTENING: {
struct sockaddr_storage addr;
socklen_t addrlen = sizeof(addr);
int new_conn_fd =
accept(conn->sock_fd, (struct sockaddr *)&addr, &addrlen);
if (new_conn_fd == -1) {
LOG_ERROR("Failed to accept");
}
(static_cast<LibeventMasterThread *>(conn->thread))
->DispatchConnection(new_conn_fd, EV_READ | EV_PERSIST);
done = true;
break;
}
case CONN_READ: {
auto res = conn->FillReadBuffer();
switch (res) {
case READ_DATA_RECEIVED:
// wait for some other event
conn->TransitState(CONN_PROCESS);
break;
case READ_NO_DATA_RECEIVED:
// process what we read
conn->TransitState(CONN_WAIT);
break;
case READ_ERROR:
// fatal error for the connection
conn->TransitState(CONN_CLOSING);
break;
}
break;
}
case CONN_WAIT : {
if (conn->UpdateEvent(EV_READ | EV_PERSIST) == false) {
LOG_ERROR("Failed to update event, closing");
conn->TransitState(CONN_CLOSING);
break;
}
conn->TransitState(CONN_READ);
done = true;
break;
}
case CONN_PROCESS : {
bool status;
if (conn->rpkt.header_parsed == false) {
// parse out the header first
if (conn->ReadPacketHeader() == false) {
// need more data
conn->TransitState(CONN_WAIT);
break;
}
}
PL_ASSERT(conn->rpkt.header_parsed == true);
if (conn->rpkt.is_initialized == false) {
// packet needs to be initialized with rest of the contents
if (conn->ReadPacket() == false) {
// need more data
conn->TransitState(CONN_WAIT);
break;
}
}
PL_ASSERT(conn->rpkt.is_initialized == true);
if (conn->pkt_manager.is_started == false) {
// We need to handle startup packet first
status = conn->pkt_manager.ProcessStartupPacket(&conn->rpkt);
conn->pkt_manager.is_started = true;
} else {
// Process all other packets
status = conn->pkt_manager.ProcessPacket(&conn->rpkt);
}
if (status == false) {
// packet processing can't proceed further
conn->TransitState(CONN_CLOSING);
} else {
// We should have responses ready to send
conn->TransitState(CONN_WRITE);
}
break;
}
case CONN_WRITE: {
// examine write packets result
switch(conn->WritePackets()) {
case WRITE_COMPLETE: {
// Input Packet can now be reset, before we parse the next packet
conn->rpkt.Reset();
conn->UpdateEvent(EV_READ | EV_PERSIST);
conn->TransitState(CONN_PROCESS);
break;
}
case WRITE_NOT_READY: {
// we can't write right now. Exit state machine
// and wait for next callback
done = true;
break;
}
case WRITE_ERROR: {
LOG_ERROR("Error during write, closing connection");
conn->TransitState(CONN_CLOSING);
break;
}
}
break;
}
case CONN_CLOSING: {
conn->CloseSocket();
done = true;
break;
}
case CONN_CLOSED: {
done = true;
break;
}
case CONN_INVALID: {
PL_ASSERT(false);
break;
}
}
}
}
}
}
| 28.796296
| 87
| 0.555466
|
xhad1234
|
48befcbd7f437ad897f4935c59fb6c8a2d7fe457
| 951
|
hpp
|
C++
|
abcd/util/Debug.hpp
|
Airbitz/airbitz-core-private
|
dc6742a5622f6d8bae750e60fcee3bb473bc67ce
|
[
"BSD-2-Clause-FreeBSD"
] | 1
|
2021-05-28T02:52:00.000Z
|
2021-05-28T02:52:00.000Z
|
abcd/util/Debug.hpp
|
Airbitz/airbitz-core-private
|
dc6742a5622f6d8bae750e60fcee3bb473bc67ce
|
[
"BSD-2-Clause-FreeBSD"
] | null | null | null |
abcd/util/Debug.hpp
|
Airbitz/airbitz-core-private
|
dc6742a5622f6d8bae750e60fcee3bb473bc67ce
|
[
"BSD-2-Clause-FreeBSD"
] | null | null | null |
/*
* Copyright (c) 2015, Airbitz, Inc.
* All rights reserved.
*
* See the LICENSE file for more information.
*/
#ifndef ABC_UTIL_DEBUG_HPP
#define ABC_UTIL_DEBUG_HPP
#include "Status.hpp"
#include "Data.hpp"
#define DEBUG_LEVEL 1
#define ABC_DebugLevel(level, ...) \
{ \
if (DEBUG_LEVEL >= level) \
{ \
ABC_DebugLog(__VA_ARGS__); \
} \
}
#define ABC_Debug(level, STR) \
{ \
if (DEBUG_LEVEL >= level) \
{ \
logInfo(STR); \
} \
}
namespace abcd {
Status
debugInitialize();
void
debugTerminate();
DataChunk
debugLogLoad();
void ABC_DebugLog(const char *format, ...);
/**
* Like `ABC_DebugLog`, but takes `std::string`.
*/
void
logInfo(const std::string &message);
} // namespace abcd
#endif
| 17.943396
| 48
| 0.500526
|
Airbitz
|
48c1a6dd1f2af3f73146257ac08639a7ba02b21e
| 2,551
|
cpp
|
C++
|
higan/ms/cpu/bus.cpp
|
13824125580/higan
|
fbdd3f980b65412c362096579869ae76730e4118
|
[
"Intel",
"ISC"
] | 38
|
2018-04-05T05:00:05.000Z
|
2022-02-06T00:02:02.000Z
|
higan/ms/cpu/bus.cpp
|
13824125580/higan
|
fbdd3f980b65412c362096579869ae76730e4118
|
[
"Intel",
"ISC"
] | 1
|
2018-04-29T19:45:14.000Z
|
2018-04-29T19:45:14.000Z
|
higan/ms/cpu/bus.cpp
|
13824125580/higan
|
fbdd3f980b65412c362096579869ae76730e4118
|
[
"Intel",
"ISC"
] | 8
|
2018-04-16T22:37:46.000Z
|
2021-02-10T07:37:03.000Z
|
auto CPU::read(uint16 addr) -> uint8 {
uint8 data;
if(auto result = cartridge.read(addr)) {
data = result();
} else if(addr >= 0xc000) {
data = ram[addr & 0x1fff];
}
if(auto result = cheat.find(addr, data)) {
data = result();
}
return data;
}
auto CPU::write(uint16 addr, uint8 data) -> void {
if(cartridge.write(addr, data)) {
} else if(addr >= 0xc000) {
ram[addr & 0x1fff] = data;
}
}
auto CPU::in(uint8 addr) -> uint8 {
switch(addr >> 6) {
case 0: {
if(Model::GameGear()) {
bool start = !platform->inputPoll(ID::Port::Hardware, ID::Device::GameGearControls, 6);
return start << 7 | 0x7f;
}
return 0xff; //SMS1 = MDR, SMS2 = 0xff
}
case 1: {
return !addr.bit(0) ? vdp.vcounter() : vdp.hcounter();
}
case 2: {
return !addr.bit(0) ? vdp.data() : vdp.status();
}
case 3: {
if(Model::MasterSystem()) {
bool reset = !platform->inputPoll(ID::Port::Hardware, ID::Device::MasterSystemControls, 0);
auto port1 = controllerPort1.device->readData();
auto port2 = controllerPort2.device->readData();
if(addr.bit(0) == 0) {
return port1.bits(0,5) << 0 | port2.bits(0,1) << 6;
} else {
return port2.bits(2,5) << 0 | reset << 4 | 1 << 5 | port1.bit(6) << 6 | port2.bit(6) << 7;
}
}
if(Model::GameGear()) {
bool up = !platform->inputPoll(ID::Port::Hardware, ID::Device::GameGearControls, 0);
bool down = !platform->inputPoll(ID::Port::Hardware, ID::Device::GameGearControls, 1);
bool left = !platform->inputPoll(ID::Port::Hardware, ID::Device::GameGearControls, 2);
bool right = !platform->inputPoll(ID::Port::Hardware, ID::Device::GameGearControls, 3);
bool one = !platform->inputPoll(ID::Port::Hardware, ID::Device::GameGearControls, 4);
bool two = !platform->inputPoll(ID::Port::Hardware, ID::Device::GameGearControls, 5);
if(!up && !down) up = 1, down = 1;
if(!left && !right) left = 1, right = 1;
if(addr.bit(0) == 0) {
return up << 0 | down << 1 | left << 2 | right << 3 | one << 4 | two << 5 | 1 << 6 | 1 << 7;
} else {
return 0xff;
}
}
return 0xff;
}
}
return 0xff;
}
auto CPU::out(uint8 addr, uint8 data) -> void {
if(addr == 0x06) {
if(Model::GameGear()) return psg.balance(data);
}
switch(addr >> 6) {
case 1: {
return psg.write(data);
}
case 2: {
return !addr.bit(0) ? vdp.data(data) : vdp.control(data);
}
case 3: {
return; //unmapped
}
}
}
| 25.257426
| 100
| 0.562132
|
13824125580
|
48c86877a2224e4bd32455579428f1b9d68b83de
| 3,321
|
cpp
|
C++
|
mainwindow.cpp
|
isc1/QtThread01
|
7f74601091ec35cee7c89546365be6400f386fbb
|
[
"MIT"
] | null | null | null |
mainwindow.cpp
|
isc1/QtThread01
|
7f74601091ec35cee7c89546365be6400f386fbb
|
[
"MIT"
] | null | null | null |
mainwindow.cpp
|
isc1/QtThread01
|
7f74601091ec35cee7c89546365be6400f386fbb
|
[
"MIT"
] | null | null | null |
// QtThread01 -- simple threaded GUI example
// see README.md for description.
// This code was written on Qt 5.11.1 on Windows 10. It may run on OS X and Linux with
// modifications but we haven't done that.
// This code is copyright 2018 inhabited.systems, and is shared under the MIT license.
// (See file MIT-License.txt) This code is unsupported.
#include "mainwindow.h"
extern QMutex mutex;
extern qreal locx;
extern qreal locy;
extern int shutdowncounter;
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent)
, mSceneWidth(600)
, mSceneHeight(600)
, mGraphicsScene(Q_NULLPTR)
, mGraphicsView(Q_NULLPTR)
, mEllipseItem(Q_NULLPTR)
, mCircleSize(100)
, mAppLoopUpdateInterval(5) // in milliseconds
{
setGeometry(0,0,mSceneWidth,mSceneHeight);
QWidget *centralWidget = new QWidget(this);
setCentralWidget(centralWidget);
mGraphicsScene = new QGraphicsScene(parent);
mGraphicsView = new QGraphicsView(mGraphicsScene);
mGraphicsView->setGeometry(0,0,mSceneWidth,mSceneHeight);
QLayout *mylayout = new QHBoxLayout();
centralWidget->setLayout(mylayout);
mylayout->addWidget(mGraphicsView);
QPen mypen;
QBrush mybrush;
mypen.setColor(QColor(Qt::transparent));
mypen.setWidth(1);
mypen.setStyle(Qt::PenStyle(1));
mybrush.setColor(QColor(0,0,0));
// set a background color
QGraphicsRectItem *rect_item1 = mGraphicsScene->addRect(0, 0, mSceneWidth, mSceneHeight);
rect_item1->setBrush(QColor(255, 243, 230)); // light tan
// create a reference square on the screen to help see where the circle ends up
QGraphicsRectItem *rect_item2 = mGraphicsScene->addRect(mSceneWidth/4+mCircleSize/1.35, mSceneHeight/4+mCircleSize/1.35, mSceneWidth/4, mSceneHeight/4);
// add the circle that is going to animate
mEllipseItem = new QGraphicsEllipseItem(0,0,mCircleSize,mCircleSize);
mGraphicsScene->addItem(mEllipseItem);
locx = 30;
locy = (mSceneHeight/2) - (mCircleSize/2);
mGraphicsScene->addEllipse(locx,locy,mCircleSize,mCircleSize,mypen,mybrush);
// For some reason, the previous addEllipse doesn't seem to setX,setY to locx,locy
// so we have to do it explicitly:
mEllipseItem->setX(locx);
mEllipseItem->setY(locy);
startAppLoopTimer();
}
MainWindow::~MainWindow()
{
// I set this to try to tell threads to quit, but it doesn't work. We need to catch the
// user clicking the X button to close the window, and make the threads quit from that.
// try https://stackoverflow.com/a/26185770/10355150
shutdowncounter = 0;
}
void MainWindow::startAppLoopTimer()
{
// associate the signal timeout() to the slot appLoopTick(), and start our update timer
QObject::connect(&mAppLoopTimer, SIGNAL(timeout()), this, SLOT(appLoopTick()));
mAppLoopTimer.start(5);
//qDebug() << __FUNCTION__ << "complete.";
}
void MainWindow::appLoopTick()
{
updatecircle();
shutdowncounter--;
//qDebug() << "(mainwindow)" << __FUNCTION__ << "locx:" << locx << "shutdowncounter: " << shutdowncounter;
mGraphicsScene->advance();
}
void MainWindow::updatecircle()
{
if (mEllipseItem == nullptr) return;
//qDebug() << "(mainwindow)" << __FUNCTION__ << "locx:" << locx << "shutdowncounter: " << shutdowncounter;
mEllipseItem->setX(locx);
}
| 34.59375
| 156
| 0.710027
|
isc1
|
48c90c29e5117c4520178a9f3f3d505cfb1dbf53
| 14,043
|
cpp
|
C++
|
Extern/JUCE/extras/JuceDemo/Source/demos/AudioDemoSynthPage.cpp
|
vinniefalco/SimpleDJ
|
30cf1929eaaf0906a1056a33378e8b330062c691
|
[
"MIT"
] | 27
|
2015-05-07T02:10:39.000Z
|
2021-06-22T14:52:50.000Z
|
Extern/JUCE/extras/JuceDemo/Source/demos/AudioDemoSynthPage.cpp
|
JoseDiazRohena/SimpleDJ
|
30cf1929eaaf0906a1056a33378e8b330062c691
|
[
"MIT"
] | null | null | null |
Extern/JUCE/extras/JuceDemo/Source/demos/AudioDemoSynthPage.cpp
|
JoseDiazRohena/SimpleDJ
|
30cf1929eaaf0906a1056a33378e8b330062c691
|
[
"MIT"
] | 14
|
2015-09-12T12:00:22.000Z
|
2022-03-08T22:24:24.000Z
|
/*
==============================================================================
This is an automatically generated file created by the Jucer!
Creation date: 21 Sep 2012 12:10:20pm
Be careful when adding custom code to these files, as only the code within
the "//[xyz]" and "//[/xyz]" sections will be retained when the file is loaded
and re-saved.
Jucer version: 1.12
------------------------------------------------------------------------------
The Jucer is part of the JUCE library - "Jules' Utility Class Extensions"
Copyright 2004-6 by Raw Material Software ltd.
==============================================================================
*/
//[Headers] You can add your own extra header files here...
//[/Headers]
#include "AudioDemoSynthPage.h"
//[MiscUserDefs] You can add your own user definitions and misc code here...
//==============================================================================
/** Our demo synth sound is just a basic sine wave..
*/
class SineWaveSound : public SynthesiserSound
{
public:
SineWaveSound()
{
}
bool appliesToNote (const int /*midiNoteNumber*/) { return true; }
bool appliesToChannel (const int /*midiChannel*/) { return true; }
};
//==============================================================================
/** Our demo synth voice just plays a sine wave..
*/
class SineWaveVoice : public SynthesiserVoice
{
public:
SineWaveVoice()
: angleDelta (0.0),
tailOff (0.0)
{
}
bool canPlaySound (SynthesiserSound* sound)
{
return dynamic_cast <SineWaveSound*> (sound) != 0;
}
void startNote (const int midiNoteNumber, const float velocity,
SynthesiserSound* /*sound*/, const int /*currentPitchWheelPosition*/)
{
currentAngle = 0.0;
level = velocity * 0.15;
tailOff = 0.0;
double cyclesPerSecond = MidiMessage::getMidiNoteInHertz (midiNoteNumber);
double cyclesPerSample = cyclesPerSecond / getSampleRate();
angleDelta = cyclesPerSample * 2.0 * double_Pi;
}
void stopNote (const bool allowTailOff)
{
if (allowTailOff)
{
// start a tail-off by setting this flag. The render callback will pick up on
// this and do a fade out, calling clearCurrentNote() when it's finished.
if (tailOff == 0.0) // we only need to begin a tail-off if it's not already doing so - the
// stopNote method could be called more than once.
tailOff = 1.0;
}
else
{
// we're being told to stop playing immediately, so reset everything..
clearCurrentNote();
angleDelta = 0.0;
}
}
void pitchWheelMoved (const int /*newValue*/)
{
// can't be bothered implementing this for the demo!
}
void controllerMoved (const int /*controllerNumber*/, const int /*newValue*/)
{
// not interested in controllers in this case.
}
void renderNextBlock (AudioSampleBuffer& outputBuffer, int startSample, int numSamples)
{
if (angleDelta != 0.0)
{
if (tailOff > 0)
{
while (--numSamples >= 0)
{
const float currentSample = (float) (sin (currentAngle) * level * tailOff);
for (int i = outputBuffer.getNumChannels(); --i >= 0;)
*outputBuffer.getSampleData (i, startSample) += currentSample;
currentAngle += angleDelta;
++startSample;
tailOff *= 0.99;
if (tailOff <= 0.005)
{
clearCurrentNote();
angleDelta = 0.0;
break;
}
}
}
else
{
while (--numSamples >= 0)
{
const float currentSample = (float) (sin (currentAngle) * level);
for (int i = outputBuffer.getNumChannels(); --i >= 0;)
*outputBuffer.getSampleData (i, startSample) += currentSample;
currentAngle += angleDelta;
++startSample;
}
}
}
}
private:
double currentAngle, angleDelta, level, tailOff;
};
// This is an audio source that streams the output of our demo synth.
class SynthAudioSource : public AudioSource
{
public:
//==============================================================================
// this collects real-time midi messages from the midi input device, and
// turns them into blocks that we can process in our audio callback
MidiMessageCollector midiCollector;
// this represents the state of which keys on our on-screen keyboard are held
// down. When the mouse is clicked on the keyboard component, this object also
// generates midi messages for this, which we can pass on to our synth.
MidiKeyboardState& keyboardState;
// the synth itself!
Synthesiser synth;
//==============================================================================
SynthAudioSource (MidiKeyboardState& keyboardState_)
: keyboardState (keyboardState_)
{
// add some voices to our synth, to play the sounds..
for (int i = 4; --i >= 0;)
{
synth.addVoice (new SineWaveVoice()); // These voices will play our custom sine-wave sounds..
synth.addVoice (new SamplerVoice()); // and these ones play the sampled sounds
}
// and add some sounds for them to play...
setUsingSineWaveSound();
}
void setUsingSineWaveSound()
{
synth.clearSounds();
synth.addSound (new SineWaveSound());
}
void setUsingSampledSound()
{
synth.clearSounds();
WavAudioFormat wavFormat;
ScopedPointer<AudioFormatReader> audioReader (wavFormat.createReaderFor (new MemoryInputStream (BinaryData::cello_wav,
BinaryData::cello_wavSize,
false),
true));
BigInteger allNotes;
allNotes.setRange (0, 128, true);
synth.addSound (new SamplerSound ("demo sound",
*audioReader,
allNotes,
74, // root midi note
0.1, // attack time
0.1, // release time
10.0 // maximum sample length
));
}
void prepareToPlay (int /*samplesPerBlockExpected*/, double sampleRate)
{
midiCollector.reset (sampleRate);
synth.setCurrentPlaybackSampleRate (sampleRate);
}
void releaseResources()
{
}
void getNextAudioBlock (const AudioSourceChannelInfo& bufferToFill)
{
// the synth always adds its output to the audio buffer, so we have to clear it
// first..
bufferToFill.clearActiveBufferRegion();
// fill a midi buffer with incoming messages from the midi input.
MidiBuffer incomingMidi;
midiCollector.removeNextBlockOfMessages (incomingMidi, bufferToFill.numSamples);
// pass these messages to the keyboard state so that it can update the component
// to show on-screen which keys are being pressed on the physical midi keyboard.
// This call will also add midi messages to the buffer which were generated by
// the mouse-clicking on the on-screen keyboard.
keyboardState.processNextMidiBuffer (incomingMidi, 0, bufferToFill.numSamples, true);
// and now get the synth to process the midi events and generate its output.
synth.renderNextBlock (*bufferToFill.buffer, incomingMidi, 0, bufferToFill.numSamples);
}
};
//[/MiscUserDefs]
//==============================================================================
AudioDemoSynthPage::AudioDemoSynthPage (AudioDeviceManager& deviceManager_)
: deviceManager (deviceManager_),
keyboardComponent (0),
sineButton (0),
sampledButton (0),
liveAudioDisplayComp (0)
{
addAndMakeVisible (keyboardComponent = new MidiKeyboardComponent (keyboardState, MidiKeyboardComponent::horizontalKeyboard));
addAndMakeVisible (sineButton = new ToggleButton (String::empty));
sineButton->setButtonText ("Use sine wave");
sineButton->setRadioGroupId (321);
sineButton->addListener (this);
sineButton->setToggleState (true, false);
addAndMakeVisible (sampledButton = new ToggleButton (String::empty));
sampledButton->setButtonText ("Use sampled sound");
sampledButton->setRadioGroupId (321);
sampledButton->addListener (this);
addAndMakeVisible (liveAudioDisplayComp = new LiveAudioInputDisplayComp());
//[UserPreSize]
//[/UserPreSize]
setSize (600, 400);
//[Constructor] You can add your own custom stuff here..
deviceManager.addAudioCallback (liveAudioDisplayComp);
synthAudioSource = new SynthAudioSource (keyboardState);
audioSourcePlayer.setSource (synthAudioSource);
deviceManager.addAudioCallback (&audioSourcePlayer);
deviceManager.addMidiInputCallback (String::empty, &(synthAudioSource->midiCollector));
//[/Constructor]
}
AudioDemoSynthPage::~AudioDemoSynthPage()
{
//[Destructor_pre]. You can add your own custom destruction code here..
audioSourcePlayer.setSource (0);
deviceManager.removeMidiInputCallback (String::empty, &(synthAudioSource->midiCollector));
deviceManager.removeAudioCallback (&audioSourcePlayer);
deviceManager.removeAudioCallback (liveAudioDisplayComp);
//[/Destructor_pre]
deleteAndZero (keyboardComponent);
deleteAndZero (sineButton);
deleteAndZero (sampledButton);
deleteAndZero (liveAudioDisplayComp);
//[Destructor]. You can add your own custom destruction code here..
//[/Destructor]
}
//==============================================================================
void AudioDemoSynthPage::paint (Graphics& g)
{
//[UserPrePaint] Add your own custom painting code here..
//[/UserPrePaint]
g.fillAll (Colours::lightgrey);
//[UserPaint] Add your own custom painting code here..
//[/UserPaint]
}
void AudioDemoSynthPage::resized()
{
keyboardComponent->setBounds (8, 96, getWidth() - 16, 64);
sineButton->setBounds (16, 176, 150, 24);
sampledButton->setBounds (16, 200, 150, 24);
liveAudioDisplayComp->setBounds (8, 8, getWidth() - 16, 64);
//[UserResized] Add your own custom resize handling here..
//[/UserResized]
}
void AudioDemoSynthPage::buttonClicked (Button* buttonThatWasClicked)
{
//[UserbuttonClicked_Pre]
//[/UserbuttonClicked_Pre]
if (buttonThatWasClicked == sineButton)
{
//[UserButtonCode_sineButton] -- add your button handler code here..
synthAudioSource->setUsingSineWaveSound();
//[/UserButtonCode_sineButton]
}
else if (buttonThatWasClicked == sampledButton)
{
//[UserButtonCode_sampledButton] -- add your button handler code here..
synthAudioSource->setUsingSampledSound();
//[/UserButtonCode_sampledButton]
}
//[UserbuttonClicked_Post]
//[/UserbuttonClicked_Post]
}
//[MiscUserCode] You can add your own definitions of your custom methods or any other code here...
//[/MiscUserCode]
//==============================================================================
#if 0
/* -- Jucer information section --
This is where the Jucer puts all of its metadata, so don't change anything in here!
BEGIN_JUCER_METADATA
<JUCER_COMPONENT documentType="Component" className="AudioDemoSynthPage" componentName=""
parentClasses="public Component" constructorParams="AudioDeviceManager& deviceManager_"
variableInitialisers="deviceManager (deviceManager_)" snapPixels="8"
snapActive="1" snapShown="1" overlayOpacity="0.330000013" fixedSize="0"
initialWidth="600" initialHeight="400">
<BACKGROUND backgroundColour="ffd3d3d3"/>
<GENERICCOMPONENT name="" id="86605ec4f02c4320" memberName="keyboardComponent"
virtualName="" explicitFocusOrder="0" pos="8 96 16M 64" class="MidiKeyboardComponent"
params="keyboardState, MidiKeyboardComponent::horizontalKeyboard"/>
<TOGGLEBUTTON name="" id="d75101df45006ba9" memberName="sineButton" virtualName=""
explicitFocusOrder="0" pos="16 176 150 24" buttonText="Use sine wave"
connectedEdges="0" needsCallback="1" radioGroupId="321" state="1"/>
<TOGGLEBUTTON name="" id="2d687b4ac3dad628" memberName="sampledButton" virtualName=""
explicitFocusOrder="0" pos="16 200 150 24" buttonText="Use sampled sound"
connectedEdges="0" needsCallback="1" radioGroupId="321" state="0"/>
<GENERICCOMPONENT name="" id="7d70eb2617f56220" memberName="liveAudioDisplayComp"
virtualName="" explicitFocusOrder="0" pos="8 8 16M 64" class="LiveAudioInputDisplayComp"
params=""/>
</JUCER_COMPONENT>
END_JUCER_METADATA
*/
#endif
| 36.007692
| 131
| 0.564053
|
vinniefalco
|
48d213e5a7c3874a240d009fc50b97f41465e1a5
| 1,137
|
cpp
|
C++
|
ProblemSolving/UpdateIT/main.cpp
|
vikaspachisia/DataStructuresAndAlgorithms
|
85aef2715ffa489d1c0d190bcd0442fb336957a2
|
[
"MIT"
] | null | null | null |
ProblemSolving/UpdateIT/main.cpp
|
vikaspachisia/DataStructuresAndAlgorithms
|
85aef2715ffa489d1c0d190bcd0442fb336957a2
|
[
"MIT"
] | null | null | null |
ProblemSolving/UpdateIT/main.cpp
|
vikaspachisia/DataStructuresAndAlgorithms
|
85aef2715ffa489d1c0d190bcd0442fb336957a2
|
[
"MIT"
] | null | null | null |
//scanf and printf is faster than cin and cout.
#include <stdio.h>
using namespace std;
#define MAX_N 10002
void solve_main_problem()
{
char testid[10];
int T, ST, VAL, N, U, Q, L, R, D[MAX_N]{};
scanf("%d",&T);
for (int t = 0; t < T; t++)
{
scanf("%s",&testid);
scanf("%d",&ST);
for (int st = 0; st < ST; st++) {
scanf("%d %d", &N, &U);
for (int i = 0; i <= N; i++)D[i] = 0;
for (int i = 1; i <= U; i++) {
scanf("%d %d %d", &L, &R, &VAL);
D[L+1] += VAL, D[R + 2] -= VAL;
}
for (int i = 1; i <= N; i++) { D[i] += D[i - 1]; }
printf("%d\n", testid);
scanf("%d",&Q);
for (int i = 1; i <= Q; i++) { scanf("%d", &VAL); printf("%d", D[VAL+1]); }
}
}
}
FILE *inStream, *outStream;
void open_unit_test_files() {
freopen_s(&inStream, "unit_test_input.txt", "r", stdin);
freopen_s(&outStream, "unit_test_output.txt", "w", stdout);
//std::ios_base::sync_with_stdio(false);
}
void close_unit_test_files() {
fclose(stdin);
fclose(stdout);
fclose(inStream);
fclose(outStream);
}
int main() {
open_unit_test_files();
solve_main_problem();
close_unit_test_files();
return 0;
}
| 21.055556
| 80
| 0.552331
|
vikaspachisia
|
48d298b12c587228bb36e2c056b37165c308ee3f
| 1,920
|
cpp
|
C++
|
examples/xtd.forms.examples/others/form_window_state/src/form_window_state.cpp
|
BaderEddineOuaich/xtd
|
6f28634c7949a541d183879d2de18d824ec3c8b1
|
[
"MIT"
] | 1
|
2022-02-25T16:53:06.000Z
|
2022-02-25T16:53:06.000Z
|
examples/xtd.forms.examples/others/form_window_state/src/form_window_state.cpp
|
leanid/xtd
|
2e1ea6537218788ca08901faf8915d4100990b53
|
[
"MIT"
] | null | null | null |
examples/xtd.forms.examples/others/form_window_state/src/form_window_state.cpp
|
leanid/xtd
|
2e1ea6537218788ca08901faf8915d4100990b53
|
[
"MIT"
] | null | null | null |
#define TRACE
#include <xtd/xtd>
using namespace xtd;
using namespace xtd::forms;
class form1 : public form {
public:
form1() {
*this << button_full_screen << button_maximize << button_minimize << button_normal;
text("Window state example");
resize += [&] {
button_full_screen.enabled(window_state() != form_window_state::full_screen&& window_state() != form_window_state::maximized);
button_maximize.enabled(window_state() != form_window_state::maximized&& window_state() != form_window_state::full_screen);
button_normal.enabled(window_state() != form_window_state::normal);
button_minimize.enabled(window_state() != form_window_state::minimized&& window_state() != form_window_state::full_screen);
ctrace << ustring::format("resize: {}, {}", size(), window_state()) << std::endl;
};
client_size({410, 200});
window_state(form_window_state::maximized);
button_full_screen.location({10, 10});
button_full_screen.text("Full screen");
button_full_screen.width(90);
button_full_screen.click += [&] {
window_state(form_window_state::full_screen);
};
button_maximize.location({110, 10});
button_maximize.text("Maximize");
button_maximize.width(90);
button_maximize.click += [&] {
window_state(form_window_state::maximized);
};
button_normal.location({210, 10});
button_normal.text("Normal");
button_normal.width(90);
button_normal.click += [&] {
window_state(form_window_state::normal);
};
button_minimize.location({310, 10});
button_minimize.text("Minimize");
button_minimize.width(90);
button_minimize.click += [&] {
window_state(form_window_state::minimized);
};
}
private:
button button_full_screen;
button button_maximize;
button button_normal;
button button_minimize;
};
int main() {
application::run(form1());
}
| 30.967742
| 132
| 0.68125
|
BaderEddineOuaich
|
48d31e8fd116ac94a27d0f06258a4bdd64a08437
| 1,054
|
cpp
|
C++
|
WonderMake/Logging/ConsoleLogger.cpp
|
nicolasgustafsson/WonderMake
|
9661d5dab17cf98e06daf6ea77c5927db54d62f9
|
[
"MIT"
] | 3
|
2020-03-27T15:25:19.000Z
|
2022-01-18T14:12:25.000Z
|
WonderMake/Logging/ConsoleLogger.cpp
|
nicolasgustafsson/WonderMake
|
9661d5dab17cf98e06daf6ea77c5927db54d62f9
|
[
"MIT"
] | null | null | null |
WonderMake/Logging/ConsoleLogger.cpp
|
nicolasgustafsson/WonderMake
|
9661d5dab17cf98e06daf6ea77c5927db54d62f9
|
[
"MIT"
] | null | null | null |
#include "pch.h"
#include "ConsoleLogger.h"
#include <iostream>
REGISTER_SYSTEM(ConsoleLogger);
ConsoleLogger::ConsoleLogger() noexcept
: mySubscriber(BindHelper(&ConsoleLogger::OnLogMessage, this))
{}
void ConsoleLogger::OnLogMessage(const SLogMessage& aMessage)
{
if (aMessage.HasTag(TagError))
SetColor(EConsoleColor::Red);
else if (aMessage.HasTag(TagWarning))
SetColor(EConsoleColor::Yellow);
else if (aMessage.HasTag(TagSuccess))
SetColor(EConsoleColor::Green);
else
SetColor(EConsoleColor::Default);
std::cout << aMessage.LogText << '\n';
}
void ConsoleLogger::SetColor(const EConsoleColor aColor) noexcept
{
auto hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
WORD attribute = 0;
switch (aColor)
{
case EConsoleColor::Blue:
attribute = 9;
break;
case EConsoleColor::Green:
attribute = 10;
break;
case EConsoleColor::Yellow:
attribute = 14;
break;
case EConsoleColor::Red:
attribute = 12;
break;
case EConsoleColor::Default:
attribute = 7;
break;
}
SetConsoleTextAttribute(hConsole, attribute);
}
| 20.269231
| 65
| 0.740987
|
nicolasgustafsson
|
48d34b74c007c31fab95977cf6d6dd9971f7dc46
| 2,318
|
cpp
|
C++
|
project2D/MushRoom.cpp
|
deadglow/AIE-AI-Assessment
|
c010dadb55b1c7152f983d11868055e275c42b42
|
[
"MIT"
] | null | null | null |
project2D/MushRoom.cpp
|
deadglow/AIE-AI-Assessment
|
c010dadb55b1c7152f983d11868055e275c42b42
|
[
"MIT"
] | null | null | null |
project2D/MushRoom.cpp
|
deadglow/AIE-AI-Assessment
|
c010dadb55b1c7152f983d11868055e275c42b42
|
[
"MIT"
] | null | null | null |
#include "MushRoom.h"
#include <iostream>
#include <fstream>
MushRoom::MushRoom(std::string path)
{
LoadMapData(path);
}
MushRoom::~MushRoom()
{
delete[] mapData;
}
int* MushRoom::GetMapData()
{
return mapData;
}
void MushRoom::LoadMapData(std::string path)
{
//-----------------------------------------------
// Map data layout
// :width height
// :i i i i i i i /n
// :i i i i i i i /n
// :i i i i i i i /n
// :i i i i i i i /n
//_______________________________________________
//Load the map
std::ifstream mushroomFile(path.c_str());
//Cache for reading from lines
std::string line;
std::string str = "";
//First line is the dimensions of the map separated by a space
std::getline(mushroomFile, line);
//Iterator to loop through line chars
auto iter = line.begin();
//Iterate through line chars until a space is found
while (*iter != ' ')
{
str.push_back(*iter);
iter++;
}
//Found width, assign then reset string
width = std::stoi(str);
str = "";
//Move iter forward to skip space
iter++;
//Height is the rest of the chars after space
while (iter != line.end())
{
str.push_back(*iter);
iter++;
}
//Found height
height = std::stoi(str);
str = "";
//Create mapData on heap as a 1d array
mapData = new int[width * height];
//Indices for coordinates
int y = 0;
int x;
//Start reading data line by line
while (std::getline(mushroomFile, line))
{
//Reset x position since its a new line
x = 0;
//Iterate through every char in line
auto iter = line.begin();
while (iter != line.end())
{
//' ' is the separator between cells
//Allows for numbers larger than one character
//(which is probably never going to be used)
if (*iter == ' ')
{
//Separator found, so add the data to mapData
SetData(x, height - 1 - y, std::stoi(str));
iter++;
x++;
//Data added, reset string
str = "";
}
else
{
str.push_back(*iter);
iter++;
}
}
//Reached end of line, go to the next one
y++;
}
}
int MushRoom::GetWidth()
{
return width;
}
int MushRoom::GetHeight()
{
return height;
}
int MushRoom::GetData(int x, int y)
{
//Access 1d array like a 2d array
return mapData[y * width + x];
}
void MushRoom::SetData(int x, int y, int data)
{
mapData[y * width + x] = data;
}
| 17.560606
| 63
| 0.612597
|
deadglow
|
48d3c666ebc87e5682a1c1166e2da7f88405e7c7
| 2,760
|
cpp
|
C++
|
yarpl/test/Single_test.cpp
|
bli7193/rsocket-cpp
|
c2abc34687f8ba6bab667029a25f1699531951e8
|
[
"Apache-2.0"
] | 217
|
2017-04-29T14:44:39.000Z
|
2022-03-29T04:06:17.000Z
|
yarpl/test/Single_test.cpp
|
bli7193/rsocket-cpp
|
c2abc34687f8ba6bab667029a25f1699531951e8
|
[
"Apache-2.0"
] | 270
|
2017-04-28T04:12:23.000Z
|
2022-03-11T20:39:33.000Z
|
yarpl/test/Single_test.cpp
|
bli7193/rsocket-cpp
|
c2abc34687f8ba6bab667029a25f1699531951e8
|
[
"Apache-2.0"
] | 83
|
2017-04-28T02:06:16.000Z
|
2022-03-11T20:35:16.000Z
|
// Copyright (c) Facebook, Inc. and its affiliates.
//
// 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 <folly/ExceptionWrapper.h>
#include <folly/synchronization/Baton.h>
#include <gtest/gtest.h>
#include <atomic>
#include "yarpl/Single.h"
#include "yarpl/single/SingleTestObserver.h"
#include "yarpl/test_utils/Tuple.h"
using namespace yarpl::single;
TEST(Single, SingleOnNext) {
auto a = Single<int>::create([](std::shared_ptr<SingleObserver<int>> obs) {
obs->onSubscribe(SingleSubscriptions::empty());
obs->onSuccess(1);
});
auto to = SingleTestObserver<int>::create();
a->subscribe(to);
to->awaitTerminalEvent();
to->assertOnSuccessValue(1);
}
TEST(Single, OnError) {
std::string errorMessage("DEFAULT->No Error Message");
auto a = Single<int>::create([](std::shared_ptr<SingleObserver<int>> obs) {
obs->onError(
folly::exception_wrapper(std::runtime_error("something broke!")));
});
auto to = SingleTestObserver<int>::create();
a->subscribe(to);
to->awaitTerminalEvent();
to->assertOnErrorMessage("something broke!");
}
TEST(Single, Just) {
auto a = Singles::just<int>(1);
auto to = SingleTestObserver<int>::create();
a->subscribe(to);
to->awaitTerminalEvent();
to->assertOnSuccessValue(1);
}
TEST(Single, Error) {
std::string errorMessage("DEFAULT->No Error Message");
auto a = Singles::error<int>(std::runtime_error("something broke!"));
auto to = SingleTestObserver<int>::create();
a->subscribe(to);
to->awaitTerminalEvent();
to->assertOnErrorMessage("something broke!");
}
TEST(Single, SingleMap) {
auto a = Single<int>::create([](std::shared_ptr<SingleObserver<int>> obs) {
obs->onSubscribe(SingleSubscriptions::empty());
obs->onSuccess(1);
});
auto to = SingleTestObserver<const char*>::create();
a->map([](int) { return "hello"; })->subscribe(to);
to->awaitTerminalEvent();
to->assertOnSuccessValue("hello");
}
TEST(Single, MapWithException) {
auto single = Singles::just<int>(3)->map([](int n) {
if (n > 2) {
throw std::runtime_error{"Too big!"};
}
return n;
});
auto observer = std::make_shared<SingleTestObserver<int>>();
single->subscribe(observer);
observer->assertOnErrorMessage("Too big!");
}
| 29.052632
| 77
| 0.692754
|
bli7193
|
48d3d37205bddbb6313b8ce311d2f11ef96ff515
| 1,129
|
hpp
|
C++
|
src/time/rk3_tvd.hpp
|
vanreeslab/murphy
|
01c9c56171fcee33cb3c1c93c25617ccf7b8ff83
|
[
"BSD-3-Clause"
] | 1
|
2021-12-01T22:12:56.000Z
|
2021-12-01T22:12:56.000Z
|
src/time/rk3_tvd.hpp
|
vanreeslab/murphy
|
01c9c56171fcee33cb3c1c93c25617ccf7b8ff83
|
[
"BSD-3-Clause"
] | null | null | null |
src/time/rk3_tvd.hpp
|
vanreeslab/murphy
|
01c9c56171fcee33cb3c1c93c25617ccf7b8ff83
|
[
"BSD-3-Clause"
] | null | null | null |
#ifndef SRC_RK3_HPP
#define SRC_RK3_HPP
#include "core/macros.hpp"
#include "core/types.hpp"
#include "grid/field.hpp"
#include "grid/grid.hpp"
#include "tools/prof.hpp"
#include "rkfunctor.hpp"
/**
* @brief provides an implementation of a RK3 -TVD using two registers
*
* For more detail, cfr
* Total Variation Diminishing Runge-Kutta Schemes, Gottlieb and Shu, 1998
* Strong Stability-Preserving High-Order Time Discretization Methods, Gottlieb et al., 2001
*
*/
class RK3_TVD {
real_t cfl_max_ = 1.0;
Grid* grid_ = nullptr;
Field* field_u_ = nullptr;
RKFunctor* f_ = nullptr;
Prof* prof_ = nullptr;
Field* field_y1_ = nullptr;
Field* field_y2_ = nullptr;
public:
explicit RK3_TVD(Grid* grid, Field* state, RKFunctor* f, Prof* prof, const real_t cfl_max = 1.0);
virtual ~RK3_TVD();
void DoDt(const real_t dt, real_t* time) const;
real_t ComputeDt(const RKFunctor* rhs, const real_t max_ve, const real_t nu = 0.0) const;
real_t ComputeDt(const RKFunctor* rhs, const Field* velocity, const real_t nu = 0.0) const;
};
#endif
| 29.710526
| 101
| 0.677591
|
vanreeslab
|
48d82faf071e49eba79bd8ad901d78ae36341065
| 17,201
|
cpp
|
C++
|
src/DevicePage.cpp
|
my-devices/gateway
|
6c2036551f2609e9834d3b7cf012db19ebeafafe
|
[
"BSL-1.0"
] | 4
|
2017-12-22T17:28:34.000Z
|
2022-03-09T16:41:44.000Z
|
src/DevicePage.cpp
|
my-devices/gateway
|
6c2036551f2609e9834d3b7cf012db19ebeafafe
|
[
"BSL-1.0"
] | null | null | null |
src/DevicePage.cpp
|
my-devices/gateway
|
6c2036551f2609e9834d3b7cf012db19ebeafafe
|
[
"BSL-1.0"
] | 1
|
2021-09-29T06:06:36.000Z
|
2021-09-29T06:06:36.000Z
|
//
// DevicePage.cpp
//
// This file has been generated from DevicePage.cpsp on 2021-11-27 20:17:05.
//
#include "DevicePage.h"
#include "Poco/Net/HTTPServerRequest.h"
#include "Poco/Net/HTTPServerResponse.h"
#include "Poco/Net/HTMLForm.h"
#include "Poco/DeflatingStream.h"
#include "DevicePageController.h"
#include "Poco/Net/NameValueCollection.h"
#include "Utility.h"
using namespace std::string_literals;
namespace MyDevices {
namespace Gateway {
DevicePage::DevicePage(DeviceManager::Ptr context):
_context(context)
{
}
void DevicePage::handleRequest(Poco::Net::HTTPServerRequest& request, Poco::Net::HTTPServerResponse& response)
{
response.setChunkedTransferEncoding(true);
response.setContentType("text/html;charset=utf-8"s);
bool _compressResponse(request.hasToken("Accept-Encoding"s, "gzip"s));
if (_compressResponse) response.set("Content-Encoding"s, "gzip"s);
Poco::Net::HTMLForm form(request, request.stream());
#line 4 "/Users/guenter/ws/git/my-devices/gateway/html/template.inc"
Poco::Net::NameValueCollection pageTemplate;
pageTemplate.set("softwareVersion", Utility::versionString());
#line 13 "/Users/guenter/ws/git/my-devices/gateway/src/DevicePage.cpsp"
DevicePageController ctrl(context(), request, form);
if (response.sent()) return;
if (ctrl.mustRedirect()) return;
if (ctrl.deviceConfig())
{
pageTemplate.set("title", "Gateway > " + ctrl.name());
}
else
{
pageTemplate.set("title", "Gateway > Unknown Device");
}
pageTemplate.set("domain", ctrl.defaultDomain());
std::ostream& _responseStream = response.send();
Poco::DeflatingOutputStream _gzipStream(_responseStream, Poco::DeflatingStreamBuf::STREAM_GZIP, 1);
std::ostream& responseStream = _compressResponse ? _gzipStream : _responseStream;
responseStream << "<!DOCTYPE HTML>\n";
responseStream << "\n";
// begin include html/template.inc
responseStream << "\n";
// end include html/template.inc
responseStream << "\n";
// begin include html/header.inc
responseStream << "<html>\n";
responseStream << " <head>\n";
responseStream << " <meta http-equiv=\"content-type\" content=\"text/html; charset=utf-8\">\n";
responseStream << " <meta http-equiv=\"X-UA-Compatible\" content=\"IE=edge,chrome=1\">\n";
responseStream << " <title>";
#line 5 "/Users/guenter/ws/git/my-devices/gateway/html/header.inc"
responseStream << ( U::htmlize(pageTemplate["title"]) );
responseStream << "</title>\n";
responseStream << " <link rel=\"stylesheet\" href=\"/css/styles.css\" type=\"text/css\"/>\n";
responseStream << " <link rel=\"icon\" href=\"/images/favicon.ico\">\n";
responseStream << " </head>\n";
responseStream << " <body lang=\"en\">\n";
responseStream << " <header>\n";
responseStream << " <div class=\"headercontainer\">\n";
responseStream << " <div class=\"header\">\n";
responseStream << "\t\t <h1>REMOTE ";
#line 13 "/Users/guenter/ws/git/my-devices/gateway/html/header.inc"
responseStream << ( U::htmlize(pageTemplate["title"]) );
responseStream << "</h1>\n";
responseStream << " </div>\n";
responseStream << " </div>\n";
responseStream << " </header>\n";
responseStream << " <div class=\"contentcontainer\">\n";
responseStream << " <div class=\"content\">\n";
// end include html/header.inc
responseStream << "\n";
responseStream << "<script language=\"JavaScript\">\n";
responseStream << "function cancelUpdateDevice(id)\n";
responseStream << "{\n";
responseStream << " document.actionForm.action.value = \"cancel\";\n";
responseStream << " document.actionForm.submit();\n";
responseStream << "}\n";
responseStream << "</script>\n";
responseStream << "\n";
responseStream << "<nav>\n";
responseStream << " <div class=\"usernav\">\n";
responseStream << " <div class=\"navigation\">\n";
responseStream << " </div>\n";
responseStream << " <div class=\"username\">\n";
responseStream << " \n";
responseStream << " ";
#line 45 "/Users/guenter/ws/git/my-devices/gateway/src/DevicePage.cpsp"
responseStream << ( ctrl.username() );
responseStream << "\n";
responseStream << " \n";
responseStream << " <a id=\"logoutLink\" href=\"#\" onclick=\"document.logout.submit()\">Sign out</a>\n";
responseStream << " </div>\n";
responseStream << " <form method=\"post\" name=\"logout\" action=\"/\">\n";
responseStream << " <input type=\"hidden\" name=\"action\" value=\"logout\">\n";
responseStream << " </form>\n";
responseStream << " <div style=\"clear: both;\"></div>\n";
responseStream << " </div>\n";
responseStream << "</nav>\n";
responseStream << "\n";
#line 56 "/Users/guenter/ws/git/my-devices/gateway/src/DevicePage.cpsp"
if (!ctrl.message().empty()) { responseStream << "\n";
responseStream << " <div class=\"error\">\n";
responseStream << " ";
#line 58 "/Users/guenter/ws/git/my-devices/gateway/src/DevicePage.cpsp"
responseStream << ( U::htmlize(ctrl.message()) );
responseStream << "\n";
responseStream << " </div>\n";
#line 60 "/Users/guenter/ws/git/my-devices/gateway/src/DevicePage.cpsp"
} responseStream << "\n";
#line 62 "/Users/guenter/ws/git/my-devices/gateway/src/DevicePage.cpsp"
if (ctrl.deviceConfig()) { responseStream << "\n";
responseStream << " <div class=\"groupbox\">\n";
responseStream << " <h2>Device Properties</h2>\n";
responseStream << "\n";
responseStream << " <form name=\"actionForm\" method=\"post\" autocomplete=\"off\">\n";
responseStream << " <input type=\"hidden\" name=\"action\" value=\"update\">\n";
responseStream << " <input type=\"hidden\" name=\"csrfToken\" value=\"";
#line 68 "/Users/guenter/ws/git/my-devices/gateway/src/DevicePage.cpsp"
responseStream << ( ctrl.csrfToken() );
responseStream << "\">\n";
responseStream << " <input type=\"hidden\" name=\"target\" value=\"";
#line 69 "/Users/guenter/ws/git/my-devices/gateway/src/DevicePage.cpsp"
responseStream << ( ctrl.deviceId() );
responseStream << "\">\n";
responseStream << " <table class=\"list\">\n";
responseStream << " <tbody>\n";
responseStream << " <tr class=\"intermediateHeader\">\n";
responseStream << " <th colspan=\"2\">\n";
responseStream << " Basic Properties\n";
responseStream << " </th>\n";
responseStream << " </tr>\n";
responseStream << " <tr class=\"even\">\n";
responseStream << " <td class=\"basicProperty\">Name</td>\n";
responseStream << " <td>\n";
responseStream << " <input type=\"text\"\n";
responseStream << " name=\"deviceName\"\n";
responseStream << " value=\"";
#line 82 "/Users/guenter/ws/git/my-devices/gateway/src/DevicePage.cpsp"
responseStream << ( U::htmlize(ctrl.name()) );
responseStream << "\"\n";
responseStream << " size=\"64\"\n";
responseStream << " maxLength=\"64\"\n";
responseStream << " class=\"form-control\">\n";
responseStream << " </td>\n";
responseStream << " </tr>\n";
responseStream << " <tr class=\"odd\">\n";
responseStream << " <td class=\"basicProperty\">ID</td>\n";
responseStream << " <td>";
#line 90 "/Users/guenter/ws/git/my-devices/gateway/src/DevicePage.cpsp"
responseStream << ( U::htmlize(ctrl.deviceId()) );
responseStream << "</td>\n";
responseStream << " </tr>\n";
responseStream << " <tr class=\"even\">\n";
responseStream << " <td class=\"basicProperty\">Domain</td>\n";
responseStream << " <td>\n";
responseStream << " <input type=\"text\"\n";
responseStream << " name=\"domain\"\n";
responseStream << " value=\"";
#line 97 "/Users/guenter/ws/git/my-devices/gateway/src/DevicePage.cpsp"
responseStream << ( U::htmlize(ctrl.domain()) );
responseStream << "\"\n";
responseStream << " size=\"64\"\n";
responseStream << " maxLength=\"64\"\n";
responseStream << " class=\"form-control\">\n";
responseStream << " </td>\n";
responseStream << " </tr>\n";
responseStream << " <tr class=\"odd\">\n";
responseStream << " <td>Device Password</td>\n";
responseStream << " <td>\n";
responseStream << " <input type=\"password\"\n";
responseStream << " name=\"password\"\n";
responseStream << " value=\"";
#line 108 "/Users/guenter/ws/git/my-devices/gateway/src/DevicePage.cpsp"
responseStream << ( U::htmlize(ctrl.password()) );
responseStream << "\"\n";
responseStream << " size=\"32\"\n";
responseStream << " maxLength=\"32\"\n";
responseStream << " class=\"form-control\">\n";
responseStream << " (optional)\n";
responseStream << " </td>\n";
responseStream << " </tr>\n";
responseStream << " <tr class=\"even\">\n";
responseStream << " <td>Status</td>\n";
responseStream << " <td>";
#line 117 "/Users/guenter/ws/git/my-devices/gateway/src/DevicePage.cpsp"
responseStream << ( ctrl.deviceStatus() );
responseStream << "</td>\n";
responseStream << " </tr>\n";
responseStream << " <tr class=\"intermediateHeader\">\n";
responseStream << " <th colspan=\"2\">\n";
responseStream << " Device Address and Forwarded Ports\n";
responseStream << " </th>\n";
responseStream << " </tr>\n";
responseStream << " <tr class=\"even\">\n";
responseStream << " <td class=\"basicProperty\">Device IP Address or Domain Name</td>\n";
responseStream << " <td>\n";
responseStream << " <input type=\"text\"\n";
responseStream << " name=\"host\"\n";
responseStream << " value=\"";
#line 129 "/Users/guenter/ws/git/my-devices/gateway/src/DevicePage.cpsp"
responseStream << ( U::htmlize(ctrl.host()) );
responseStream << "\"\n";
responseStream << " size=\"64\"\n";
responseStream << " maxLength=\"64\"\n";
responseStream << " class=\"form-control\">\n";
responseStream << " </td>\n";
responseStream << " </tr>\n";
responseStream << " <tr class=\"odd\">\n";
responseStream << " <td class=\"basicProperty\">HTTP Server Port</td>\n";
responseStream << " <td>\n";
responseStream << " <input type=\"number\"\n";
responseStream << " name=\"httpPort\"\n";
responseStream << " value=\"";
#line 140 "/Users/guenter/ws/git/my-devices/gateway/src/DevicePage.cpsp"
responseStream << ( U::htmlize(ctrl.httpPort()) );
responseStream << "\"\n";
responseStream << " size=\"5\"\n";
responseStream << " maxLength=\"5\"\n";
responseStream << " min=\"0\"\n";
responseStream << " max=\"65535\"\n";
responseStream << " class=\"form-control\">\n";
responseStream << " <input type=\"checkbox\"\n";
responseStream << " name=\"httpsRequired\"\n";
responseStream << " value=\"true\"\n";
responseStream << " ";
#line 149 "/Users/guenter/ws/git/my-devices/gateway/src/DevicePage.cpsp"
responseStream << ( ctrl.httpsEnable() ? "checked" : "" );
responseStream << "\n";
responseStream << " class=\"form-control\">\n";
responseStream << " <label for=\"httpsRequired\">Requires HTTPS</label>\n";
responseStream << " </td>\n";
responseStream << " </tr>\n";
responseStream << " <tr class=\"even\">\n";
responseStream << " <td class=\"basicProperty\">SSH Server Port</td>\n";
responseStream << " <td>\n";
responseStream << " <input type=\"number\"\n";
responseStream << " name=\"sshPort\"\n";
responseStream << " value=\"";
#line 159 "/Users/guenter/ws/git/my-devices/gateway/src/DevicePage.cpsp"
responseStream << ( U::htmlize(ctrl.sshPort()) );
responseStream << "\"\n";
responseStream << " size=\"5\"\n";
responseStream << " maxLength=\"5\"\n";
responseStream << " min=\"1\"\n";
responseStream << " max=\"65535\"\n";
responseStream << " class=\"form-control\">\n";
responseStream << " (optional)\n";
responseStream << " </td>\n";
responseStream << " </tr>\n";
responseStream << " <tr class=\"odd\">\n";
responseStream << " <td class=\"basicProperty\">VNC Server Port</td>\n";
responseStream << " <td>\n";
responseStream << " <input type=\"number\"\n";
responseStream << " name=\"vncPort\"\n";
responseStream << " value=\"";
#line 173 "/Users/guenter/ws/git/my-devices/gateway/src/DevicePage.cpsp"
responseStream << ( U::htmlize(ctrl.vncPort()) );
responseStream << "\"\n";
responseStream << " size=\"5\"\n";
responseStream << " maxLength=\"5\"\n";
responseStream << " min=\"1\"\n";
responseStream << " max=\"65535\"\n";
responseStream << " class=\"form-control\">\n";
responseStream << " (optional)\n";
responseStream << " </td>\n";
responseStream << " </tr>\n";
responseStream << " <tr class=\"even\">\n";
responseStream << " <td class=\"basicProperty\">RDP Server Port</td>\n";
responseStream << " <td>\n";
responseStream << " <input type=\"number\"\n";
responseStream << " name=\"rdpPort\"\n";
responseStream << " value=\"";
#line 187 "/Users/guenter/ws/git/my-devices/gateway/src/DevicePage.cpsp"
responseStream << ( U::htmlize(ctrl.rdpPort()) );
responseStream << "\"\n";
responseStream << " size=\"5\"\n";
responseStream << " maxLength=\"5\"\n";
responseStream << " min=\"1\"\n";
responseStream << " max=\"65535\"\n";
responseStream << " class=\"form-control\">\n";
responseStream << " (optional)\n";
responseStream << " </td>\n";
responseStream << " </tr>\n";
responseStream << " <tr class=\"odd\">\n";
responseStream << " <td>Additional Forwarded TCP Ports</td>\n";
responseStream << " <td>\n";
responseStream << " <input type=\"text\"\n";
responseStream << " name=\"ports\"\n";
responseStream << " value=\"";
#line 201 "/Users/guenter/ws/git/my-devices/gateway/src/DevicePage.cpsp"
responseStream << ( ctrl.extraPorts() );
responseStream << "\"\n";
responseStream << " size=\"40\"\n";
responseStream << " maxLength=\"40\"\n";
responseStream << " class=\"form-control\">\n";
responseStream << " (comma-separated)\n";
responseStream << " </td>\n";
responseStream << " </tr>\n";
responseStream << " <tr>\n";
responseStream << " <td colspan=\"2\" style=\"text-align: right\">\n";
responseStream << " <a href=\"#\" onclick=\"cancelUpdateDevice()\">Cancel</a>\n";
responseStream << " \n";
responseStream << " <input type=\"submit\" value=\"Save\" class=\"form-control\">\n";
responseStream << " </td>\n";
responseStream << " </tr>\n";
responseStream << " </tbody>\n";
responseStream << " </table>\n";
responseStream << " </form>\n";
responseStream << " </div>\n";
#line 219 "/Users/guenter/ws/git/my-devices/gateway/src/DevicePage.cpsp"
} responseStream << " ";
responseStream << "\n";
// begin include html/footer.inc
responseStream << " </div>\n";
responseStream << " </div>\n";
responseStream << " <footer>\n";
responseStream << " <div class=\"footercontainer\">\n";
responseStream << " <div class=\"footer\">\n";
responseStream << " ";
#line 6 "/Users/guenter/ws/git/my-devices/gateway/html/footer.inc"
responseStream << ( pageTemplate["softwareVersion"] );
responseStream << " | © 2015-2021 by <a href=\"https://macchina.io\">Applied Informatics GmbH</a> | Gateway Domain: ";
#line 6 "/Users/guenter/ws/git/my-devices/gateway/html/footer.inc"
responseStream << ( U::htmlize(pageTemplate["domain"]) );
responseStream << "\n";
responseStream << " </div>\n";
responseStream << " </div>\n";
responseStream << " </footer>\n";
responseStream << " </body>\n";
responseStream << "</html>\n";
// end include html/footer.inc
responseStream << "\n";
if (_compressResponse) _gzipStream.close();
}
} } // namespace MyDevices::Gateway
| 47.780556
| 124
| 0.565432
|
my-devices
|
48dc8ec4b272b234dce70371486b61593228249d
| 2,195
|
cpp
|
C++
|
Kamek/src/levelnames.cpp
|
N-I-N-0/NSMBWii-Mod
|
56e45eeb3696f7dfa75dca13fdc2a384c8baa5fe
|
[
"MIT"
] | 5
|
2021-07-02T19:37:47.000Z
|
2021-08-21T21:31:55.000Z
|
Kamek/src/levelnames.cpp
|
N-I-N-0/NSMBWii-Mod
|
56e45eeb3696f7dfa75dca13fdc2a384c8baa5fe
|
[
"MIT"
] | null | null | null |
Kamek/src/levelnames.cpp
|
N-I-N-0/NSMBWii-Mod
|
56e45eeb3696f7dfa75dca13fdc2a384c8baa5fe
|
[
"MIT"
] | 3
|
2021-03-11T09:42:52.000Z
|
2022-01-31T00:12:59.000Z
|
#include <common.h>
#include <actors.h>
#include <stage.h>
#include "levelinfo_old.h"
#include "fileload.h"
#include "layoutlib.h"
//#define DEBUG_NAMES
#ifndef DEBUG_NAMES
#endif
extern char CurrentLevel;
extern char CurrentWorld;
int DoNames(int state) {
int wnum = (int)CurrentWorld;
int lnum = (int)CurrentLevel;
//OSReport("DoNames 1 ...\n");
// Skip the title screen
// and only process the code if the State is set to 1
// (the screen has been initialised)
//OSReport("World: %p, Level: %p, state: %p\n", wnum, lnum, state);
if (state == 1 && lnum != STAGE_TITLE) {
// grab the CRSIN object
Actor *ptr = FindActorByType(CRSIN, 0);
OSReport("DoNames (levelnames.cpp) 2 ...\n");
// FIX !!!!!
if (ptr != 0) {
void *worldObj = EmbeddedLayout_FindTextBoxByName((Layout*)((u32)ptr+0xB0), "TXT_WorldName");
void *levelObj = EmbeddedLayout_FindTextBoxByName((Layout*)((u32)ptr+0xB0), "TXT_LevelName");
if (worldObj == 0 || levelObj == 0) return state;
/*char *file = RetrieveFileFromArc(ARC_TABLE, "Mario", "newer/names.bin");
char *worldname = file + (wnum * 0x40);
char *levelname = file + 0x280 + (wnum * 0xA80) + (lnum * 0x40);*/
FileHandle fh;
void *info = LoadFile(&fh, "/NewerRes/LevelInfo.bin");
OSReport("LevelInfo.bin loaded ...\n");
LevelInfo_Prepare(&fh);
LevelInfo_Entry *entry = LevelInfo_SearchSlot(info, wnum, lnum);
char *worldname = LevelInfo_GetName(info, entry);
char *levelname = "";
OSReport("levelname: %p\n", levelname);
OSReport("worldname: %p\n", worldname);
void *vtable = *((void**)levelObj);
void *funcaddr = *((void**)((u32)vtable+0x7C));
int (*SetString)(void*, unsigned short*, unsigned short);
SetString = (int(*)(void*, unsigned short*, unsigned short))funcaddr;
unsigned short wbuffer[0x40], lbuffer[0x40];
for (int i = 0; i < 0x40; i++) {
wbuffer[i] = (unsigned short)worldname[i];
lbuffer[i] = (unsigned short)levelname[i];
}
SetString(worldObj, wbuffer, 0);
SetString(levelObj, lbuffer, 0);
FreeFile(&fh);
}
} else {
}
return state;
}
int DoNamesTest2(int state, u32 ptr) {
return DoNames(state);
}
| 27.4375
| 96
| 0.645558
|
N-I-N-0
|
48de86ea9cb2d42f4074f28d37c355c09f5bd3fd
| 3,249
|
cpp
|
C++
|
packages/data_gen/electron_photon/src/DataGen_AdjointIncoherentGridGenerator.cpp
|
lkersting/SCR-2123
|
06ae3d92998664a520dc6a271809a5aeffe18f72
|
[
"BSD-3-Clause"
] | null | null | null |
packages/data_gen/electron_photon/src/DataGen_AdjointIncoherentGridGenerator.cpp
|
lkersting/SCR-2123
|
06ae3d92998664a520dc6a271809a5aeffe18f72
|
[
"BSD-3-Clause"
] | null | null | null |
packages/data_gen/electron_photon/src/DataGen_AdjointIncoherentGridGenerator.cpp
|
lkersting/SCR-2123
|
06ae3d92998664a520dc6a271809a5aeffe18f72
|
[
"BSD-3-Clause"
] | null | null | null |
//---------------------------------------------------------------------------//
//!
//! \file DataGen_AdjointIncoherentGridGenerator.cpp
//! \author Alex Robinson
//! \brief Adjoint incoherent grid generator definition
//!
//---------------------------------------------------------------------------//
// FRENSIE Includes
#include "DataGen_AdjointIncoherentGridGenerator.hpp"
#include "Utility_PhysicalConstants.hpp"
#include "Utility_ContractException.hpp"
namespace DataGen{
// Initialize the static member data
double AdjointIncoherentGridGenerator::s_min_table_energy = 0.0001;
double AdjointIncoherentGridGenerator::s_max_table_energy = 20;
const double AdjointIncoherentGridGenerator::s_max_table_energy_nudge_factor =
0.01;
double AdjointIncoherentGridGenerator::s_nudged_max_table_energy =
s_max_table_energy*(1.0+s_max_table_energy_nudge_factor);
double AdjointIncoherentGridGenerator::s_energy_to_max_energy_nudge_factor =
1e-6;
//! Set the min table energy (default is 0.0001 MeV)
void AdjointIncoherentGridGenerator::setMinTableEnergy(
const double min_energy )
{
// Make sure the min energy is valid
testPrecondition( min_energy > 0.0 );
testPrecondition( min_energy < s_max_table_energy );
s_min_table_energy = min_energy;
}
// Get the min table energy
double AdjointIncoherentGridGenerator::getMinTableEnergy()
{
return s_min_table_energy;
}
// Set the max table energy (default is 20.0 MeV)
void AdjointIncoherentGridGenerator::setMaxTableEnergy(
const double max_energy )
{
// Make sure the max energy is valid
testPrecondition( max_energy > 0.0 );
testPrecondition( max_energy > s_min_table_energy );
s_max_table_energy = max_energy;
s_nudged_max_table_energy =
s_max_table_energy*(1.0+s_max_table_energy_nudge_factor);
}
// Get the max table energy
double AdjointIncoherentGridGenerator::getMaxTableEnergy()
{
return s_max_table_energy;
}
//! Get the max table energy nudge factor
double AdjointIncoherentGridGenerator::getNudgedMaxTableEnergy()
{
return s_nudged_max_table_energy;
}
// Set the energy to max energy nudge factor
/*! \details Setting a factor of 0.0 means that every max energy grid will
* start at the corresponding energy. This can be problematic for log
* interpolation since the adjoint incoherent cross section is zero when
* the energy is equal to the max energy. By pushing the first max energy
* slightly above the corresponding energy with this factor, that problem
* can be avoided (usually leading to smaller grids that converge faster).
*/
void AdjointIncoherentGridGenerator::setEnergyToMaxEnergyNudgeFactor(
const double factor )
{
// Make sure the factor is valid
testPrecondition( factor >= 0.0 );
testPrecondition( factor <= 0.0001 );
s_energy_to_max_energy_nudge_factor = factor;
}
// Get the energy to max energy nudge factor
double AdjointIncoherentGridGenerator::getEnergyToMaxEnergyNudgeFactor()
{
return s_energy_to_max_energy_nudge_factor;
}
} // end DataGen namespace
//---------------------------------------------------------------------------//
// end DataGen_AdjointIncoherentGridGenerator.cpp
//---------------------------------------------------------------------------//
| 32.818182
| 79
| 0.709449
|
lkersting
|
48e26af1d53050950cd807a2b6d8e128e3ff1d8c
| 5,420
|
hpp
|
C++
|
src/uml/src_gen/uml/impl/ReadVariableActionImpl.hpp
|
dataliz9r/MDE4CPP
|
9c5ce01c800fb754c371f1a67f648366eeabae49
|
[
"MIT"
] | null | null | null |
src/uml/src_gen/uml/impl/ReadVariableActionImpl.hpp
|
dataliz9r/MDE4CPP
|
9c5ce01c800fb754c371f1a67f648366eeabae49
|
[
"MIT"
] | 1
|
2019-03-01T00:54:13.000Z
|
2019-03-04T02:15:50.000Z
|
src/uml/src_gen/uml/impl/ReadVariableActionImpl.hpp
|
vallesch/MDE4CPP
|
7f8a01dd6642820913b2214d255bef2ea76be309
|
[
"MIT"
] | null | null | null |
//********************************************************************
//*
//* Warning: This file was generated by ecore4CPP Generator
//*
//********************************************************************
#ifndef UML_READVARIABLEACTIONREADVARIABLEACTIONIMPL_HPP
#define UML_READVARIABLEACTIONREADVARIABLEACTIONIMPL_HPP
//*********************************
// generated Includes
//Model includes
#include "../ReadVariableAction.hpp"
#include "uml/impl/VariableActionImpl.hpp"
//*********************************
namespace uml
{
class ReadVariableActionImpl :virtual public VariableActionImpl, virtual public ReadVariableAction
{
public:
ReadVariableActionImpl(const ReadVariableActionImpl & obj);
virtual std::shared_ptr<ecore::EObject> copy() const;
private:
ReadVariableActionImpl& operator=(ReadVariableActionImpl const&) = delete;
protected:
friend class UmlFactoryImpl;
ReadVariableActionImpl();
virtual std::shared_ptr<ReadVariableAction> getThisReadVariableActionPtr() const;
virtual void setThisReadVariableActionPtr(std::weak_ptr<ReadVariableAction> thisReadVariableActionPtr);
//Additional constructors for the containments back reference
ReadVariableActionImpl(std::weak_ptr<uml::Activity > par_activity);
//Additional constructors for the containments back reference
ReadVariableActionImpl(std::weak_ptr<uml::StructuredActivityNode > par_inStructuredNode);
//Additional constructors for the containments back reference
ReadVariableActionImpl(std::weak_ptr<uml::Namespace > par_namespace);
//Additional constructors for the containments back reference
ReadVariableActionImpl(std::weak_ptr<uml::Element > par_owner);
public:
//destructor
virtual ~ReadVariableActionImpl();
//*********************************
// Operations
//*********************************
/*!
The multiplicity of the variable must be compatible with the multiplicity of the output pin.
variable.compatibleWith(result) */
virtual bool compatible_multiplicity(Any diagnostics,std::map < Any, Any > context) ;
/*!
The type and ordering of the result OutputPin are the same as the type and ordering of the variable.
result.type =variable.type and
result.isOrdered = variable.isOrdered */
virtual bool type_and_ordering(Any diagnostics,std::map < Any, Any > context) ;
//*********************************
// Attributes Getter Setter
//*********************************
//*********************************
// Reference
//*********************************
/*!
The OutputPin on which the result values are placed.
<p>From package UML::Actions.</p> */
virtual std::shared_ptr<uml::OutputPin > getResult() const ;
/*!
The OutputPin on which the result values are placed.
<p>From package UML::Actions.</p> */
virtual void setResult(std::shared_ptr<uml::OutputPin> _result_result) ;
//*********************************
// Union Getter
//*********************************
/*!
ActivityGroups containing the ActivityNode.
<p>From package UML::Activities.</p> */
virtual std::shared_ptr<Union<uml::ActivityGroup>> getInGroup() const ;/*!
The ordered set of OutputPins representing outputs from the Action.
<p>From package UML::Actions.</p> */
virtual std::shared_ptr<SubsetUnion<uml::OutputPin, uml::Element>> getOutput() const ;/*!
The Elements owned by this Element.
<p>From package UML::CommonStructure.</p> */
virtual std::shared_ptr<Union<uml::Element>> getOwnedElement() const ;/*!
The Element that owns this Element.
<p>From package UML::CommonStructure.</p> */
virtual std::weak_ptr<uml::Element > getOwner() const ;/*!
The RedefinableElement that is being redefined by this element.
<p>From package UML::Classification.</p> */
virtual std::shared_ptr<Union<uml::RedefinableElement>> getRedefinedElement() const ;
//*********************************
// Structural Feature Getter/Setter
//*********************************
virtual std::shared_ptr<ecore::EObject> eContainer() const ;
//*********************************
// Persistence Functions
//*********************************
virtual void load(std::shared_ptr<persistence::interfaces::XLoadHandler> loadHandler) ;
virtual void loadAttributes(std::shared_ptr<persistence::interfaces::XLoadHandler> loadHandler, std::map<std::string, std::string> attr_list);
virtual void loadNode(std::string nodeName, std::shared_ptr<persistence::interfaces::XLoadHandler> loadHandler, std::shared_ptr<uml::UmlFactory> modelFactory);
virtual void resolveReferences(const int featureID, std::list<std::shared_ptr<ecore::EObject> > references) ;
virtual void save(std::shared_ptr<persistence::interfaces::XSaveHandler> saveHandler) const ;
virtual void saveContent(std::shared_ptr<persistence::interfaces::XSaveHandler> saveHandler) const;
protected:
virtual std::shared_ptr<ecore::EClass> eStaticClass() const;
virtual Any eGet(int featureID, bool resolve, bool coreType) const ;
virtual bool internalEIsSet(int featureID) const ;
virtual bool eSet(int featureID, Any newValue) ;
private:
std::weak_ptr<ReadVariableAction> m_thisReadVariableActionPtr;
};
}
#endif /* end of include guard: UML_READVARIABLEACTIONREADVARIABLEACTIONIMPL_HPP */
| 38.169014
| 162
| 0.65
|
dataliz9r
|
48eb0c326683df21cac8f4746870a48f58ece808
| 5,439
|
cpp
|
C++
|
source/ktwgEngine/contact.cpp
|
JasonWyx/ktwgEngine
|
410ba799f7000895995b9f9fc59d738f293f8871
|
[
"MIT"
] | null | null | null |
source/ktwgEngine/contact.cpp
|
JasonWyx/ktwgEngine
|
410ba799f7000895995b9f9fc59d738f293f8871
|
[
"MIT"
] | 12
|
2019-09-15T07:48:18.000Z
|
2019-12-08T17:23:22.000Z
|
source/ktwgEngine/contact.cpp
|
JasonWyx/ktwgEngine
|
410ba799f7000895995b9f9fc59d738f293f8871
|
[
"MIT"
] | null | null | null |
#include "contact.h"
#include "contactlistener.h"
#include "fcollider.h"
#include "boxcollider.h"
#include "rigidbody.h"
#include "gjk.h"
#include "entity.h"
void Contact::Update(ContactListener* listener)
{
// Get all necessary information from colliders
// transform must be a world transformation
BoxCollider* colliderA = pair_.colliders_[0];
BoxCollider* colliderB = pair_.colliders_[1];
RigidBody* bodyA = colliderA->GetRigidBody();
RigidBody* bodyB = colliderB->GetRigidBody();
bool isTriggerContact = colliderA->GetIsTrigger() || colliderB->GetIsTrigger();
// Contact is a trigger contact, no need for generating contact, so we do GJK collision detection check
if (isTriggerContact)
{
GJK::GJKOutput output = GJK::GJK(colliderA, colliderB);
float radiiA = colliderA->GetRadius();
float radiiB = colliderB->GetRadius();
bool colliding = output.distance_ <= radiiA + radiiB;
// Update the contact state.
if (colliding == true)
flags_ |= flags_ & CF_COLLIDING ? CF_WASCOLLIDING : CF_COLLIDING;
else
{
if (flags_ & CF_COLLIDING)
{
flags_ &= ~CF_COLLIDING;
flags_ |= CF_WASCOLLIDING;
}
else
flags_ &= ~CF_WASCOLLIDING;
}
}
else
{
// Copy out the old manifold
Manifold oldManifold = manifold_;
Vec3 oldTangent0 = oldManifold.tangentVectors_[0];
Vec3 oldTangent1 = oldManifold.tangentVectors_[1];
// Solve and generate a manifold
SolveCollision();
ComputeBasis(manifold_.normal_, &manifold_.tangentVectors_[0], &manifold_.tangentVectors_[1]);
for (auto i = (int8_t)0; i < manifold_.contactCount_; ++i)
{
ContactInfo* contactInfo = manifold_.contactInfos_ + i;
contactInfo->Initialize();
for (auto j = 0; j < oldManifold.contactCount_; ++j)
{
ContactInfo* oldContactInfo = oldManifold.contactInfos_ + j;
if (contactInfo->id_.key == oldContactInfo->id_.key)
{
contactInfo->normalImpulse_ = oldContactInfo->normalImpulse_;
Vec3 friction = oldTangent0 * oldContactInfo->tangentImpulse_[0] + oldTangent1 * oldContactInfo->tangentImpulse_[1];
contactInfo->tangentImpulse_[0] = Dot(friction, manifold_.tangentVectors_[0]);
contactInfo->tangentImpulse_[1] = Dot(friction, manifold_.tangentVectors_[1]);
break;
}
}
}
// If manifold has contact generated, It means there's a collision/no collision in this frame
if (manifold_.contactCount_ > 0)
{
// If previous flag is Colliding, then current flag will be WasColliding because
// the contact is already in colliding previous frame.
// Whereas if the flag is not colliding, it means that the contact just begin its collision
// So it is considered Colliding in this frame.
flags_ |= flags_ & CF_COLLIDING ? CF_WASCOLLIDING : CF_COLLIDING;
}
else
{
// If no contact is generated in the manifold, it could mean the contact just ended collision
// So if previous flag is Colliding, the current flag will not have Colliding set but only
// wasColliding set to imply it had a past collision.
// Whereas if flag is not in colliding anymore, we should reset the wasColliding flag to imply
// there's no past collision this frame
if (flags_ & CF_COLLIDING)
{
flags_ &= ~CF_COLLIDING;
flags_ |= CF_WASCOLLIDING;
}
else
flags_ &= ~CF_WASCOLLIDING;
}
}
bool isColliding = flags_ & CF_COLLIDING;
bool wasColliding = flags_ & CF_WASCOLLIDING;
// Wake the bodies associated with the shapes if the contact has began.
if (isColliding != wasColliding)
{
bodyA->SetAwake(true);
bodyB->SetAwake(true);
}
// Collision detection events information are passed to the event dispatcher
if (listener)
{
if (isTriggerContact)
{
if (isColliding && !wasColliding)
listener->TriggerStarted(this);
else if (!isColliding && wasColliding)
listener->TriggerEnded(this);
else if (isColliding && wasColliding)
listener->TriggerPersist(this);
}
else
{
if (isColliding && !wasColliding)
listener->ContactStarted(this);
else if (!isColliding && wasColliding)
listener->ContactEnded(this);
else if (isColliding && wasColliding)
listener->ContactPersist(this);
}
}
}
void Contact::SolveCollision()
{
CheckBoxToBox(manifold_, pair_.colliders_[0], pair_.colliders_[1]);
}
void Contact::DispatchEvent(ContactListener* listener)
{
BoxCollider* colliderA = pair_.colliders_[0];
BoxCollider* colliderB = pair_.colliders_[1];
bool isTriggerContact = colliderA->GetIsTrigger() || colliderB->GetIsTrigger();
bool isColliding = flags_ & CF_COLLIDING;
bool wasColliding = flags_ & CF_WASCOLLIDING;
if (listener)
{
if (isTriggerContact)
{
if (isColliding && !wasColliding)
listener->TriggerStarted(this);
else if (!isColliding && wasColliding)
listener->TriggerEnded(this);
else if (isColliding && wasColliding)
listener->TriggerPersist(this);
}
else
{
if (isColliding && !wasColliding)
listener->ContactStarted(this);
else if (!isColliding && wasColliding)
listener->ContactEnded(this);
else if (isColliding && wasColliding)
listener->ContactPersist(this);
}
}
}
| 31.807018
| 126
| 0.668138
|
JasonWyx
|
48eb6daa171615dce1bd44281b1aa03b6536eae2
| 450
|
cpp
|
C++
|
utils/jsonutil.cpp
|
InkosiZhong/Space
|
d38f9595e02700eafbd1b44306bff24c00ef6933
|
[
"MIT"
] | 4
|
2021-09-18T02:56:09.000Z
|
2022-03-16T12:38:39.000Z
|
utils/jsonutil.cpp
|
InkosiZhong/Space
|
d38f9595e02700eafbd1b44306bff24c00ef6933
|
[
"MIT"
] | null | null | null |
utils/jsonutil.cpp
|
InkosiZhong/Space
|
d38f9595e02700eafbd1b44306bff24c00ef6933
|
[
"MIT"
] | 1
|
2022-01-11T16:44:50.000Z
|
2022-01-11T16:44:50.000Z
|
#include "jsonutil.h"
Util::JsonUtil::JsonUtil(std::string str) {
parseJson(str);
}
bool Util::JsonUtil::parseJson(std::string str) {
Json::CharReaderBuilder b;
Json::CharReader* reader(b.newCharReader());
JSONCPP_STRING errs;
bool ret = reader->parse(str.c_str(), str.c_str() + std::strlen(str.c_str()), &m_json, &errs);
delete reader;
return ret;
}
const Json::Value& Util::JsonUtil::getJson() {
return m_json;
}
| 23.684211
| 98
| 0.662222
|
InkosiZhong
|
48edae10b343ddee3e9f0e133d6af4b00ea353fc
| 2,240
|
cpp
|
C++
|
library/view/controls/focusable_border.cpp
|
topillar/PuTTY-ng
|
1f5bf26de0f42e03ef4f100fa879b16216d61abf
|
[
"MIT"
] | 39
|
2019-06-22T12:25:54.000Z
|
2022-03-14T05:42:44.000Z
|
library/view/controls/focusable_border.cpp
|
topillar/PuTTY-ng
|
1f5bf26de0f42e03ef4f100fa879b16216d61abf
|
[
"MIT"
] | 5
|
2019-06-29T10:58:43.000Z
|
2020-09-04T08:44:09.000Z
|
library/view/controls/focusable_border.cpp
|
topillar/PuTTY-ng
|
1f5bf26de0f42e03ef4f100fa879b16216d61abf
|
[
"MIT"
] | 10
|
2019-08-07T06:08:23.000Z
|
2022-03-14T05:42:47.000Z
|
#include "focusable_border.h"
#include "ui_gfx/canvas_skia.h"
#include "ui_gfx/insets.h"
namespace
{
// Define the size of the insets
const int kTopInsetSize = 4;
const int kLeftInsetSize = 4;
const int kBottomInsetSize = 4;
const int kRightInsetSize = 4;
// Color settings for border.
// These are tentative, and should be derived from theme, system
// settings and current settings.
// TODO(saintlou): understand why this is not factored/shared somewhere
const SkColor kFocusedBorderColor = SK_ColorCYAN;
const SkColor kDefaultBorderColor = SK_ColorGRAY;
}
namespace view
{
FocusableBorder::FocusableBorder()
: has_focus_(false),
insets_(kTopInsetSize, kLeftInsetSize,
kBottomInsetSize, kRightInsetSize) {}
void FocusableBorder::Paint(const View& view, gfx::Canvas* canvas) const
{
SkRect rect;
rect.set(SkIntToScalar(0), SkIntToScalar(0),
SkIntToScalar(view.width()), SkIntToScalar(view.height()));
SkScalar corners[8] =
{
// top-left
SkIntToScalar(insets_.left()),
SkIntToScalar(insets_.top()),
// top-right
SkIntToScalar(insets_.right()),
SkIntToScalar(insets_.top()),
// bottom-right
SkIntToScalar(insets_.right()),
SkIntToScalar(insets_.bottom()),
// bottom-left
SkIntToScalar(insets_.left()),
SkIntToScalar(insets_.bottom()),
};
SkPath path;
path.addRoundRect(rect, corners);
SkPaint paint;
paint.setStyle(SkPaint::kStroke_Style);
paint.setFlags(SkPaint::kAntiAlias_Flag);
// TODO(oshima): Copy what WebKit does for focused border.
paint.setColor(has_focus_ ? kFocusedBorderColor : kDefaultBorderColor);
paint.setStrokeWidth(SkIntToScalar(has_focus_ ? 2 : 1));
canvas->AsCanvasSkia()->drawPath(path, paint);
}
void FocusableBorder::GetInsets(gfx::Insets* insets) const
{
*insets = insets_;
}
void FocusableBorder::SetInsets(int top, int left, int bottom, int right)
{
insets_.Set(top, left, bottom, right);
}
} //namespace view
| 29.866667
| 79
| 0.632143
|
topillar
|
48ef738189014736312ddf3d2d0eb40222708568
| 2,573
|
cpp
|
C++
|
src/saveMap.cpp
|
softdream/Slam-Project-Of-MyOwn
|
6d6db8a5761e8530971b203983ea2215620aa5c2
|
[
"Apache-2.0"
] | 21
|
2021-07-19T08:15:53.000Z
|
2022-03-31T07:07:55.000Z
|
src/saveMap.cpp
|
Forrest-Z/Slam-Project-Of-MyOwn
|
6d6db8a5761e8530971b203983ea2215620aa5c2
|
[
"Apache-2.0"
] | 3
|
2022-03-02T12:55:37.000Z
|
2022-03-07T12:12:57.000Z
|
src/saveMap.cpp
|
softdream/Slam-Project-Of-MyOwn
|
6d6db8a5761e8530971b203983ea2215620aa5c2
|
[
"Apache-2.0"
] | 4
|
2021-08-12T15:11:09.000Z
|
2022-01-08T14:20:36.000Z
|
#include "saveMap.h"
namespace slam{
SaveMap::SaveMap()
{
}
SaveMap::~SaveMap()
{
}
bool SaveMap::openMapFile( const std::string &fileName )
{
outfile.open( fileName, std::ios::binary | std::ios::out );
if( !outfile.is_open() ){
std::cerr<<"Failed to open the map file ..."<<std::endl;
return false;
}
std::cerr<<"Open the Map File ..."<<std::endl;
return true;
}
void SaveMap::closeMapFile()
{
return outfile.close();
}
void SaveMap::setInputMapData( const OccupiedMap &map )
{
occupiedMap = map;
isSetInputMapData = true;
}
bool SaveMap::saveGridOccupiedMap()
{
if( !isSetInputMapData ){
return false;
}
// 1. first write the map information
int sizeX = occupiedMap.getSizeX();
int sizeY = occupiedMap.getSizeY();
Eigen::Vector2i center = occupiedMap.getMapCenter();
int centerX = center(0);
int centerY = center(1);
float cellLength = occupiedMap.getCellLength();
float scale = occupiedMap.getScale();
// cells' number
int cellsNumber = occupiedMap.getCellsNumber();
outfile.write( reinterpret_cast<char *>( &sizeX ), sizeof( sizeX ) );
outfile.write( reinterpret_cast<char *>( &sizeY ), sizeof( sizeY ) );
outfile.write( reinterpret_cast<char *>( ¢erX ), sizeof( centerX ) );
outfile.write( reinterpret_cast<char *>( ¢erY ), sizeof( centerY ) );
outfile.write( reinterpret_cast<char *>( &cellLength ), sizeof( cellLength ) );
outfile.write( reinterpret_cast<char *>( &scale ), sizeof( scale ) );
outfile.write( reinterpret_cast<char *>( &cellsNumber ), sizeof( cellsNumber ) );
// 2. write the GridCell Operations information
float logOddsPocc = occupiedMap.getLogOddsPoccValue();
float logOddsPfree = occupiedMap.getLogOddsPfreeValue();
outfile.write( reinterpret_cast<char *>( &logOddsPocc ), sizeof( logOddsPocc ));
outfile.write( reinterpret_cast<char *>( &logOddsPfree ), sizeof( logOddsPfree ) );
// 3. write the Occupied Grid Map information
// TODO ... not important
// 4. write the GridCell information, it is a std::vector
std::vector<GridCell> mapArray = occupiedMap.getMapArray();
outfile.write( reinterpret_cast<char *>( mapArray.data() ), mapArray.size() * sizeof( GridCell ) );
return true;
}
bool SaveMap::operator()( const std::string &fileName, const OccupiedMap &map )
{
// 1. open the file
if( !openMapFile( fileName ) ){
return false;
}
// 2. set the input occupied grid map
setInputMapData( map );
// 3. save the occupied grid map
if( !saveGridOccupiedMap() ){
return false;
}
// 4. close the file
closeMapFile();
return true;
}
}
| 23.18018
| 100
| 0.690634
|
softdream
|
f701b5eb4571d0dace475292f6ee1b6ce56cbcf2
| 5,408
|
cpp
|
C++
|
components/hifi3/rkdsp/drivers/intc/intc.cpp
|
h-hys/rk2108_202012_SDK
|
c0880365a8eb208979df0a45ae350c8fe8f565c6
|
[
"Apache-2.0"
] | null | null | null |
components/hifi3/rkdsp/drivers/intc/intc.cpp
|
h-hys/rk2108_202012_SDK
|
c0880365a8eb208979df0a45ae350c8fe8f565c6
|
[
"Apache-2.0"
] | 1
|
2021-08-19T10:47:10.000Z
|
2021-08-19T10:47:10.000Z
|
components/hifi3/rkdsp/drivers/intc/intc.cpp
|
h-hys/rk2108_202012_SDK
|
c0880365a8eb208979df0a45ae350c8fe8f565c6
|
[
"Apache-2.0"
] | 3
|
2021-04-24T23:33:56.000Z
|
2022-01-14T07:13:38.000Z
|
/*
* Copyright (c) 2019 Rockchip Electronics Co. Ltd.
* Author: Huaping Liao <huaping.liao@rock-chips.com>
*
* 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 "intc.h"
#include <string.h>
#include <stdint.h>
#include <xtensa/hal.h>
#include <xtensa/core-macros.h>
#include <xtensa/xtruntime.h>
#include "error.h"
#include "io.h"
#include "iomap.h"
#include "section.h"
#define REG_L 32
#define INTC_IRQ_TYPE IRQ_LEVEL0
/* DSP INTC registers */
#define INTC_IRQ_INTEN_L 0x00
#define INTC_IRQ_INTEN_H 0x04
#define INTC_IRQ_INTMASK_L 0x08
#define INTC_IRQ_INTMASK_H 0x0c
#define INTC_IRQ_INTFORCE_L 0x10
#define INTC_IRQ_INTFORCE_H 0x14
#define INTC_IRQ_RAWSTATUS_L 0x18
#define INTC_IRQ_RAWSTATUS_H 0x1c
#define INTC_IRQ_STATUS_L 0x20
#define INTC_IRQ_STATUS_H 0x24
#define INTC_IRQ_MASKSTATUS_L 0x28
#define INTC_IRQ_MASKSTATUS_H 0x2c
#define INTC_IRQ_FINALSTATUS_L 0x30
#define INTC_IRQ_FINALSTATUS_H 0x34
#define INTC_IRQ_PLEVEL 0xd8
#define INTC_IRQ_PR_OFFSET 0xe8
struct irq_info {
enum irq_num irq_num;
isr_t isr;
void *params;
};
struct intc_regs {
volatile uint32_t inten_l;
volatile uint32_t inten_h;
volatile uint32_t intmask_l;
volatile uint32_t intmask_h;
volatile uint32_t intforce_l;
volatile uint32_t intforce_h;
volatile uint32_t rawstatus_l;
volatile uint32_t rawstatus_h;
volatile uint32_t status_l;
volatile uint32_t status_h;
volatile uint32_t maskstatus_l;
volatile uint32_t maskstatus_h;
volatile uint32_t finalstatus_l;
volatile uint32_t finalstatus_h;
volatile uint32_t res0[0xd8 - 0x34];
volatile uint32_t plevel;
volatile uint32_t res1[0xe8 - 0xd8];
volatile uint32_t pr_offset;
};
static __sys_data__ struct irq_info g_irqs[IRQ_MAX_NUM];
extern "C" void intc_irq_handler(void *arg)
{
uint32_t irq_num;
uint32_t status_l, status_h;
struct intc_regs *intc_reg = (struct intc_regs *)DSP_INTC_BASE;
// _xtos_clear_ints(INTC_IRQ_TYPE);
status_l = intc_reg->status_l;
status_h = intc_reg->status_h;
for (irq_num = 0; irq_num < IRQ_MAX_NUM; irq_num++) {
if (irq_num < REG_L) {
if (status_l & 1)
break;
status_l >>= 1;
} else {
if (status_h & 1)
break;
status_h >>= 1;
}
}
if (irq_num < IRQ_MAX_NUM && g_irqs[irq_num].isr)
g_irqs[irq_num].isr((enum irq_num)irq_num, g_irqs[irq_num].params);
return;
}
__sys__ int irq_mask(enum irq_num irq_num)
{
struct intc_regs *intc_reg = (struct intc_regs*)DSP_INTC_BASE;
if (irq_num >= IRQ_MAX_NUM || irq_num < 0)
return -EINVALID;
if (irq_num < REG_L)
intc_reg->intmask_l |= (0x1 << (irq_num & 0x1f));
else
intc_reg->intmask_h |= (0x1 << ((irq_num - REG_L) & 0x1f));
return 0;
}
__sys__ int irq_unmask(enum irq_num irq_num)
{
struct intc_regs *intc_reg = (struct intc_regs *)DSP_INTC_BASE;
if (irq_num >= IRQ_MAX_NUM || irq_num < 0)
return -EINVALID;
if (irq_num < REG_L)
intc_reg->intmask_l &= (~(0x1 << (irq_num & 0x1f)));
else
intc_reg->intmask_h &= (~(0x1 << ((irq_num - REG_L) & 0x1f)));
return 0;
}
__sys__ int irq_register_isr(enum irq_num irq_num, isr_t isr, void* params)
{
if (irq_num >= IRQ_MAX_NUM || irq_num < 0)
return -EINVALID;
g_irqs[irq_num].isr = isr;
g_irqs[irq_num].irq_num = irq_num;
g_irqs[irq_num].params = params;
return 0;
}
__sys__ int irq_unregister_isr(enum irq_num irq_num)
{
if (irq_num >= IRQ_MAX_NUM || irq_num < 0)
return -EINVALID;
g_irqs[irq_num].isr = NULL;
g_irqs[irq_num].irq_num = IRQ_MAX_NUM;
g_irqs[irq_num].params = NULL;
return 0;
}
__sys__ int irq_enable(enum irq_num irq_num)
{
struct intc_regs *intc_reg = (struct intc_regs *)DSP_INTC_BASE;
if (irq_num >= IRQ_MAX_NUM || irq_num < 0)
return -EINVALID;
if (irq_num < REG_L)
intc_reg->inten_l |= (0x1 << (irq_num & 0x1f));
else
intc_reg->inten_h |= (0x1 << ((irq_num - REG_L) & 0x1f));
return 0;
}
__sys__ int irq_disable(enum irq_num irq_num)
{
struct intc_regs *intc_reg = (struct intc_regs *)DSP_INTC_BASE;
if (irq_num >= IRQ_MAX_NUM || irq_num < 0)
return -EINVALID;
if (irq_num < REG_L)
intc_reg->inten_l &= (~(0x1 << (irq_num & 0x1f)));
else
intc_reg->inten_h &= (~(0x1 << ((irq_num - REG_L) & 0x1f)));
return 0;
}
__sys__ int intc_init(void)
{
memset(g_irqs, 0, sizeof(g_irqs));
_xtos_set_interrupt_handler(INTC_IRQ_TYPE,
(_xtos_handler)&intc_irq_handler);
_xtos_interrupt_enable(INTC_IRQ_TYPE);
return 0;
}
__sys__ int intc_deinit(void)
{
_xtos_interrupt_disable(INTC_IRQ_TYPE);
return 0;
}
| 26.252427
| 75
| 0.66716
|
h-hys
|
f708082fb3f69836363b51a23717eaaffa118604
| 3,751
|
cpp
|
C++
|
Visual Mercutio/zModel/PSS_UserEntity.cpp
|
Jeanmilost/Visual-Mercutio
|
f079730005b6ce93d5e184bb7c0893ccced3e3ab
|
[
"MIT"
] | 1
|
2022-01-31T06:24:24.000Z
|
2022-01-31T06:24:24.000Z
|
Visual Mercutio/zModel/PSS_UserEntity.cpp
|
Jeanmilost/Visual-Mercutio
|
f079730005b6ce93d5e184bb7c0893ccced3e3ab
|
[
"MIT"
] | 2
|
2021-04-11T15:50:42.000Z
|
2021-06-05T08:23:04.000Z
|
Visual Mercutio/zModel/PSS_UserEntity.cpp
|
Jeanmilost/Visual-Mercutio
|
f079730005b6ce93d5e184bb7c0893ccced3e3ab
|
[
"MIT"
] | 2
|
2021-01-08T00:55:18.000Z
|
2022-01-31T06:24:18.000Z
|
/****************************************************************************
* ==> PSS_UserEntity ------------------------------------------------------*
****************************************************************************
* Description : Provides an user entity *
* Developer : Processsoft *
****************************************************************************/
#include "stdafx.h"
#include "PSS_UserEntity.h"
// processsoft
#include "zBaseLib\PSS_BaseDocument.h"
#include "zBaseLib\PSS_GUID.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
//---------------------------------------------------------------------------
// Serialization
//---------------------------------------------------------------------------
IMPLEMENT_SERIAL(PSS_UserEntity, CObject, g_DefVersion)
//---------------------------------------------------------------------------
// PSS_UserEntity
//---------------------------------------------------------------------------
PSS_UserEntity::PSS_UserEntity(const CString& name,
const CString& description,
const float cost,
PSS_UserEntity* pParent) :
CObject(),
m_pParent(pParent),
m_EntityName(name),
m_EntityDescription(description),
m_EntityCost(cost)
{
CreateGUID();
}
//---------------------------------------------------------------------------
PSS_UserEntity::PSS_UserEntity(const PSS_UserEntity& other) :
CObject(),
m_pParent(NULL),
m_EntityCost(0.0f)
{
*this = other;
}
//---------------------------------------------------------------------------
PSS_UserEntity::~PSS_UserEntity()
{}
//---------------------------------------------------------------------------
PSS_UserEntity& PSS_UserEntity::operator = (const PSS_UserEntity& other)
{
m_GUID = other.m_GUID;
m_EntityName = other.m_EntityName;
m_EntityDescription = other.m_EntityDescription;
m_EntityCost = other.m_EntityCost;
return *this;
}
//---------------------------------------------------------------------------
PSS_UserEntity* PSS_UserEntity::Clone() const
{
return new PSS_UserEntity(*this);
}
//---------------------------------------------------------------------------
#ifdef _DEBUG
void PSS_UserEntity::AssertValid() const
{
CObject::AssertValid();
}
#endif
//---------------------------------------------------------------------------
#ifdef _DEBUG
void PSS_UserEntity::Dump(CDumpContext& dc) const
{
CObject::Dump(dc);
}
#endif
//---------------------------------------------------------------------------
void PSS_UserEntity::Serialize(CArchive& ar)
{
if (ar.IsStoring())
{
// write the elements
ar << m_GUID;
ar << m_EntityName;
ar << m_EntityDescription;
ar << m_EntityCost;
}
else
{
// read the elements
CString s;
ar >> s;
PSS_BaseDocument* pBaseDoc = dynamic_cast<PSS_BaseDocument*>(ar.m_pDocument);
if (pBaseDoc && pBaseDoc->GetDocumentStamp().GetInternalVersion() >= 19)
{
m_GUID = s;
ar >> m_EntityName;
}
else
{
CreateGUID();
m_EntityName = s;
}
ar >> m_EntityDescription;
ar >> m_EntityCost;
}
}
//---------------------------------------------------------------------------
void PSS_UserEntity::CreateGUID()
{
m_GUID = PSS_GUID::CreateNewGUID();
}
//---------------------------------------------------------------------------
| 31.258333
| 85
| 0.384164
|
Jeanmilost
|
f7082d839adb42570f822c19cd5030ddc1d6d7f9
| 142
|
hpp
|
C++
|
engine/include/ECS/EntityID.hpp
|
Trypio/Aeyon3D
|
6e630228fe8f8fe269ab1dfc835a7c7c5d314c2b
|
[
"MIT"
] | null | null | null |
engine/include/ECS/EntityID.hpp
|
Trypio/Aeyon3D
|
6e630228fe8f8fe269ab1dfc835a7c7c5d314c2b
|
[
"MIT"
] | null | null | null |
engine/include/ECS/EntityID.hpp
|
Trypio/Aeyon3D
|
6e630228fe8f8fe269ab1dfc835a7c7c5d314c2b
|
[
"MIT"
] | null | null | null |
//
//
//
#ifndef AEYON3D_ENTITYID_HPP
#define AEYON3D_ENTITYID_HPP
#include "UUID.hpp"
namespace aeyon
{
using EntityID = UUID;
}
#endif
| 8.875
| 28
| 0.71831
|
Trypio
|
f70a2db5f8ca8998a0bee8002662fe5fa85330ca
| 1,254
|
cpp
|
C++
|
tests/geometry/PointTest.cpp
|
cuhkshenzhen/CUHKSZLib
|
4ad122d7e736cda3e768c8ae8dcad1f9fb195a1f
|
[
"MIT"
] | null | null | null |
tests/geometry/PointTest.cpp
|
cuhkshenzhen/CUHKSZLib
|
4ad122d7e736cda3e768c8ae8dcad1f9fb195a1f
|
[
"MIT"
] | 29
|
2017-04-26T09:15:28.000Z
|
2017-05-21T15:50:37.000Z
|
tests/geometry/PointTest.cpp
|
cuhkshenzhen/CUHKSZLib
|
4ad122d7e736cda3e768c8ae8dcad1f9fb195a1f
|
[
"MIT"
] | 7
|
2017-04-26T09:32:39.000Z
|
2021-11-03T02:00:07.000Z
|
#include "geometry/Point.h"
#include "gtest/gtest.h"
TEST(Point, initialize) {
cuhksz::Point<1> a1, b1(5);
EXPECT_DOUBLE_EQ(b1[0], 5);
cuhksz::Point<2> a2, b2(2, 3);
EXPECT_DOUBLE_EQ(b2[0], 2);
EXPECT_DOUBLE_EQ(b2[1], 3);
cuhksz::Point<3> a3, b3(1, 2, 3);
EXPECT_DOUBLE_EQ(b3[0], 1);
EXPECT_DOUBLE_EQ(b3[1], 2);
EXPECT_DOUBLE_EQ(b3[2], 3);
}
TEST(GVector, addition) {
cuhksz::GVector<2> a(2, 3), b(1, 5), c;
c = a + b;
EXPECT_DOUBLE_EQ(c[0], 3);
EXPECT_DOUBLE_EQ(c[1], 8);
}
TEST(GVector, subtraction) {
cuhksz::GVector<2> a(2, 3), b(1, 5), c;
c = a - b;
EXPECT_DOUBLE_EQ(c[0], 1);
EXPECT_DOUBLE_EQ(c[1], -2);
}
TEST(GVector, mulNumber) {
cuhksz::GVector<2> a(2, 3), b;
b = a * 2;
EXPECT_DOUBLE_EQ(b[0], 4);
EXPECT_DOUBLE_EQ(b[1], 6);
a = 2 * b;
EXPECT_DOUBLE_EQ(a[0], 8);
EXPECT_DOUBLE_EQ(a[1], 12);
}
TEST(GVector, dotProduct) {
cuhksz::GVector<2> a(2, 3), b(3, 5);
EXPECT_DOUBLE_EQ(dot(a, b), 21);
a = cuhksz::GVector<2>(-2, 3);
b = cuhksz::GVector<2>(1, -5);
EXPECT_DOUBLE_EQ(a * b, -17);
}
TEST(GVector, crossProduct) {
cuhksz::Point<2> a(2, 3), b(3, 5);
EXPECT_DOUBLE_EQ(cross(a, b), 1);
}
TEST(GVector, len) {
cuhksz::GVector<2> a(3, 4);
EXPECT_DOUBLE_EQ(a.len(), 5);
}
| 20.557377
| 41
| 0.600478
|
cuhkshenzhen
|
f70e36711b3cc099812f883eb1af2d856b5a6cf3
| 2,246
|
hpp
|
C++
|
include/codegen/include/UnityEngine/Analytics/DataPrivacy_UserPostData.hpp
|
Futuremappermydud/Naluluna-Modifier-Quest
|
bfda34370764b275d90324b3879f1a429a10a873
|
[
"MIT"
] | 1
|
2021-11-12T09:29:31.000Z
|
2021-11-12T09:29:31.000Z
|
include/codegen/include/UnityEngine/Analytics/DataPrivacy_UserPostData.hpp
|
Futuremappermydud/Naluluna-Modifier-Quest
|
bfda34370764b275d90324b3879f1a429a10a873
|
[
"MIT"
] | null | null | null |
include/codegen/include/UnityEngine/Analytics/DataPrivacy_UserPostData.hpp
|
Futuremappermydud/Naluluna-Modifier-Quest
|
bfda34370764b275d90324b3879f1a429a10a873
|
[
"MIT"
] | 2
|
2021-10-03T02:14:20.000Z
|
2021-11-12T09:29:36.000Z
|
// Autogenerated from CppHeaderCreator on 7/27/2020 3:10:20 PM
// Created by Sc2ad
// =========================================================================
#pragma once
#pragma pack(push, 8)
// Begin includes
#include "utils/typedefs.h"
// Including type: System.ValueType
#include "System/ValueType.hpp"
// Including type: UnityEngine.Analytics.DataPrivacy
#include "UnityEngine/Analytics/DataPrivacy.hpp"
#include "utils/il2cpp-utils.hpp"
// Completed includes
// Begin forward declares
// Completed forward declares
// Type namespace: UnityEngine.Analytics
namespace UnityEngine::Analytics {
// Autogenerated type: UnityEngine.Analytics.DataPrivacy/UserPostData
struct DataPrivacy::UserPostData : public System::ValueType {
public:
// public System.String appid
// Offset: 0x0
::Il2CppString* appid;
// public System.String userid
// Offset: 0x8
::Il2CppString* userid;
// public System.Int64 sessionid
// Offset: 0x10
int64_t sessionid;
// public System.String platform
// Offset: 0x18
::Il2CppString* platform;
// public System.UInt32 platformid
// Offset: 0x20
uint platformid;
// public System.String sdk_ver
// Offset: 0x28
::Il2CppString* sdk_ver;
// public System.Boolean debug_device
// Offset: 0x30
bool debug_device;
// public System.String deviceid
// Offset: 0x38
::Il2CppString* deviceid;
// public System.String plugin_ver
// Offset: 0x40
::Il2CppString* plugin_ver;
// Creating value type constructor for type: UserPostData
UserPostData(::Il2CppString* appid_ = {}, ::Il2CppString* userid_ = {}, int64_t sessionid_ = {}, ::Il2CppString* platform_ = {}, uint platformid_ = {}, ::Il2CppString* sdk_ver_ = {}, bool debug_device_ = {}, ::Il2CppString* deviceid_ = {}, ::Il2CppString* plugin_ver_ = {}) : appid{appid_}, userid{userid_}, sessionid{sessionid_}, platform{platform_}, platformid{platformid_}, sdk_ver{sdk_ver_}, debug_device{debug_device_}, deviceid{deviceid_}, plugin_ver{plugin_ver_} {}
}; // UnityEngine.Analytics.DataPrivacy/UserPostData
}
DEFINE_IL2CPP_ARG_TYPE(UnityEngine::Analytics::DataPrivacy::UserPostData, "UnityEngine.Analytics", "DataPrivacy/UserPostData");
#pragma pack(pop)
| 41.592593
| 476
| 0.696794
|
Futuremappermydud
|
f70f38d9a6c6f07d0088a7d031341a57564ff7a4
| 2,227
|
cpp
|
C++
|
engine/scene/AbstractSceneComponent.cpp
|
zapolnov/game_engine
|
cd22dc0f49aeadd660eec3ea9b95b1ca2696f97a
|
[
"MIT",
"Unlicense"
] | null | null | null |
engine/scene/AbstractSceneComponent.cpp
|
zapolnov/game_engine
|
cd22dc0f49aeadd660eec3ea9b95b1ca2696f97a
|
[
"MIT",
"Unlicense"
] | null | null | null |
engine/scene/AbstractSceneComponent.cpp
|
zapolnov/game_engine
|
cd22dc0f49aeadd660eec3ea9b95b1ca2696f97a
|
[
"MIT",
"Unlicense"
] | null | null | null |
/*
* Copyright (c) 2015 Nikolay Zapolnov (zapolnov@gmail.com).
*
* 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 "AbstractSceneComponent.h"
namespace B3D
{
AbstractSceneComponent::AbstractSceneComponent()
{
}
AbstractSceneComponent::~AbstractSceneComponent()
{
}
void AbstractSceneComponent::onBeforeSizeChanged(IScene*, glm::vec2&)
{
}
void AbstractSceneComponent::onAfterSizeChanged(IScene*, const glm::vec2&)
{
}
void AbstractSceneComponent::onBeforeUpdateScene(IScene*, double)
{
}
void AbstractSceneComponent::onAfterUpdateScene(IScene*, double)
{
}
void AbstractSceneComponent::onBeforeDrawScene(const IScene*, ICanvas*)
{
}
void AbstractSceneComponent::onAfterDrawScene(const IScene*, ICanvas*)
{
}
void AbstractSceneComponent::onBeforeTouchEvent(TouchEvent, int, glm::vec2&, bool&)
{
}
void AbstractSceneComponent::onAfterTouchEvent(TouchEvent, int, const glm::vec2&, bool&)
{
}
void AbstractSceneComponent::onBeforeSendEvent(const IEvent*, bool)
{
}
void AbstractSceneComponent::onAfterSendEvent(const IEvent*, bool)
{
}
}
| 30.094595
| 92
| 0.722946
|
zapolnov
|
f7103674b2725a30db075d0b9875f92863943a91
| 2,163
|
hpp
|
C++
|
src/budget/MoveRuleCommand.hpp
|
vimofthevine/UnderBudget
|
5711be8e5da3cb7a78da007fe43cf1ce1b796493
|
[
"Apache-2.0"
] | 2
|
2016-07-17T02:12:44.000Z
|
2016-11-22T14:04:55.000Z
|
src/budget/MoveRuleCommand.hpp
|
vimofthevine/UnderBudget
|
5711be8e5da3cb7a78da007fe43cf1ce1b796493
|
[
"Apache-2.0"
] | null | null | null |
src/budget/MoveRuleCommand.hpp
|
vimofthevine/UnderBudget
|
5711be8e5da3cb7a78da007fe43cf1ce1b796493
|
[
"Apache-2.0"
] | null | null | null |
/*
* Copyright 2013 Kyle Treubig
*
* 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.
*/
#ifndef MOVERULECOMMAND_HPP
#define MOVERULECOMMAND_HPP
// Qt include(s)
#include <QList>
#include <QUndoCommand>
// UnderBudget include(s)
#include "budget/AssignmentRule.hpp"
// Forward delcaration(s)
class AssignmentRules;
namespace ub {
/**
* An undoable command to move an existing rule within the rules list.
*
* @ingroup rule_commands
*/
class MoveRuleCommand : public QUndoCommand
{
public:
/**
* Constructs a new move rule command. It is critical to note that the
* rules list pointer being given is not owned by this object, and it
* may be deleted externally at any time. Since the `QUndoStack` that
* will take ownership of this command is tied to the `Session` that
* also holds a `QSharedPointer` to the encompassing budget, it should
* be impossible for the rules list to be deleted while this command
* is still relevant.
*
* @param[in] rules rules list
* @param[in] from original index from which to move the rule
* @param[in] to destination index to which to move the rule
* @param[in] parent parent undoable command for grouping
*/
MoveRuleCommand(AssignmentRules* rules, int from, int to,
QUndoCommand* parent);
// Overriding methods
int id() const;
bool mergeWith(const QUndoCommand* command);
void redo();
void undo();
private:
/** Move rule command ID */
static const int ID;
/** Rules list */
AssignmentRules* rules;
/** Original index of the rule to be moved */
const int oldIndex;
/** New index of the rule to be moved */
const int newIndex;
};
}
#endif //MOVERULECOMMAND_HPP
| 27.730769
| 75
| 0.725381
|
vimofthevine
|
f71498253a5849507519a721c7e7613c58cdbc29
| 1,628
|
cpp
|
C++
|
SurfaceReconstruction/App/Main.cpp
|
namibj/TSR
|
df14f4a9fc175b2a6b0c14b3ace924f2364afe7b
|
[
"BSD-3-Clause"
] | 102
|
2017-10-17T10:10:59.000Z
|
2022-01-19T02:10:29.000Z
|
SurfaceReconstruction/App/Main.cpp
|
namibj/TSR
|
df14f4a9fc175b2a6b0c14b3ace924f2364afe7b
|
[
"BSD-3-Clause"
] | 2
|
2019-12-21T11:59:15.000Z
|
2020-09-08T11:38:36.000Z
|
SurfaceReconstruction/App/Main.cpp
|
namibj/TSR
|
df14f4a9fc175b2a6b0c14b3ace924f2364afe7b
|
[
"BSD-3-Clause"
] | 27
|
2017-10-18T09:37:34.000Z
|
2022-03-22T01:30:51.000Z
|
/*
* Copyright (C) 2018 by Author: Aroudj, Samir
* TU Darmstadt - Graphics, Capture and Massively Parallel Computing
* All rights reserved.
*
* This software may be modified and distributed under the terms
* of the BSD 3-Clause license. See the License.txt file for details.
*/
#include "App/TSR.h"
#include "Platform/ResourceManagement/MemoryManager.h"
#include "Platform/Utilities/HelperFunctions.h"
using namespace Platform;
using namespace std;
#ifdef MEMORY_MANAGEMENT
const uint32 ResourceManagement::DEFAULT_POOL_BUCKET_NUMBER = 5;
const uint16 ResourceManagement::DEFAULT_POOL_BUCKET_CAPACITIES[DEFAULT_POOL_BUCKET_NUMBER] = { 1024, 1024, 1024, 1024, 1024 };
const uint16 ResourceManagement::DEFAULT_POOL_BUCKET_GRANULARITIES[DEFAULT_POOL_BUCKET_NUMBER] = { 16, 32, 64, 128, 256 };
#endif /// MEMORY_MANAGEMENT
#ifdef _WINDOWS
int32 WINAPI WinMain(HINSTANCE applicationHandle, HINSTANCE unused, LPSTR commandLineArguments, int32 windowShowState)
{
#else
int main(int argumentCount, const char *commandLineArguments[])
{
#endif // _WINDOWS
// do cool stuff
{
vector<string> arguments;
#ifdef _WINDOWS
Utilities::getCommandLineArguments(arguments, commandLineArguments);
#else
Utilities::getCommandLineArguments(arguments, commandLineArguments, argumentCount);
#endif // _WINDOWS
TSR application
(
#ifdef _WINDOWS
applicationHandle,
#endif // _WINDOWS
arguments
);
application.run();
}
#ifdef MEMORY_MANAGEMENT
ResourceManagement::MemoryManager::shutDown();
#endif /// MEMORY_MANAGEMENT
return 0;
}
| 29.6
| 129
| 0.7414
|
namibj
|
f71844aa3ae2e1920253e6c6df586e9eaace0c2b
| 2,364
|
cpp
|
C++
|
dragwidget.cpp
|
sergiosvieira/mog
|
f23d2b18851bb58c3e60aae9b10deec023f2c9c8
|
[
"MIT"
] | null | null | null |
dragwidget.cpp
|
sergiosvieira/mog
|
f23d2b18851bb58c3e60aae9b10deec023f2c9c8
|
[
"MIT"
] | null | null | null |
dragwidget.cpp
|
sergiosvieira/mog
|
f23d2b18851bb58c3e60aae9b10deec023f2c9c8
|
[
"MIT"
] | null | null | null |
#include <QtWidgets>
#include "dragwidget.h"
DragWidget::DragWidget(DragWidgetType dragType, QWidget *parent)
: QLabel(parent)
{
setMinimumSize(32, 32);
setFrameStyle(QFrame::Sunken | QFrame::StyledPanel);
// setAcceptDrops(true);
QString imgPath;
switch (dragType) {
case DragWidgetType::ShipNK:
imgPath = ":/images/ShipNK.png";
break;
case DragWidgetType::ShipSK:
imgPath = ":/images/ShipSK.png";
break;
case DragWidgetType::AirportNK:
imgPath = ":/images/AirportNK.png";
break;
case DragWidgetType::AirportSK:
imgPath = ":/images/AirportSK.png";
break;
case DragWidgetType::HelicopterCarNK:
imgPath = ":/images/HelicopterCarNK";
break;
case DragWidgetType::HelicopterCarSK:
imgPath = ":/images/HelicopterCarSK.png";
break;
}
type = dragType;
setPixmap(QPixmap(imgPath));
move(0, 0);
setAttribute(Qt::WA_DeleteOnClose);
}
void DragWidget::mousePressEvent(QMouseEvent *event)
{
QPixmap pixmap = *this->pixmap();;
QMimeData *mimeData = new QMimeData;
switch (type) {
case DragWidgetType::ShipNK:
mimeData->setText("ShipNK");
break;
case DragWidgetType::ShipSK:
mimeData->setText("ShipSK");
break;
case DragWidgetType::AirportNK:
mimeData->setText("AirportNK");
break;
case DragWidgetType::AirportSK:
mimeData->setText("AirportSK");
break;
case DragWidgetType::HelicopterCarNK:
mimeData->setText("HelicopterCarNK");
break;
case DragWidgetType::HelicopterCarSK:
mimeData->setText("HelicopterCarSK");
break;
}
QDrag *drag = new QDrag(this);
drag->setMimeData(mimeData);
drag->setPixmap(pixmap);
drag->setHotSpot(event->pos());
QPixmap tempPixmap = pixmap;
QPainter painter;
painter.begin(&tempPixmap);
painter.fillRect(pixmap.rect(), QColor(127, 127, 127, 127));
painter.end();
setPixmap(tempPixmap);
if (drag->exec(Qt::CopyAction | Qt::MoveAction, Qt::CopyAction) == Qt::MoveAction) {
close();
} else {
show();
setPixmap(pixmap);
}
}
DragWidgetType DragWidget::getType()
{
return type;
}
| 26.266667
| 89
| 0.604061
|
sergiosvieira
|
f728cabf6b5d607ee401447f71862a76c52f2c63
| 2,401
|
cpp
|
C++
|
div15.cpp
|
ohmyjons/SPOJ-1
|
870ae3b072a3fbc89149b35fe5649a74512a8f60
|
[
"Unlicense"
] | 264
|
2015-01-08T10:07:01.000Z
|
2022-03-26T04:11:51.000Z
|
div15.cpp
|
ohmyjons/SPOJ-1
|
870ae3b072a3fbc89149b35fe5649a74512a8f60
|
[
"Unlicense"
] | 17
|
2016-04-15T03:38:07.000Z
|
2020-10-30T00:33:57.000Z
|
div15.cpp
|
ohmyjons/SPOJ-1
|
870ae3b072a3fbc89149b35fe5649a74512a8f60
|
[
"Unlicense"
] | 127
|
2015-01-08T04:56:44.000Z
|
2022-02-25T18:40:37.000Z
|
// 2009-04-19
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <cassert>
#include <string.h>
using namespace std;
int fox(int a,int b)
{
int tot=0,n1=a,n2=b;
while ((n1>2) && (n1>n2+1))
tot+=3,n1-=3;
while ((n2>2) && (n2>n1+1))
tot+=3,n2-=3;
return(tot+min(n1,n2)*2);
}
int main()
{
//freopen("spoj.txt","r",stdin);
//vars
int t=10,a,b;
bool zero;
static char s[3005];
int ndig[3];
static char dig[3][3005];
int nout;
static char out[3005];
//testcase loop
scanf("%d\n",&t);
while (t--)
{
//input
scanf("%s",s);
//separate by %3
ndig[0]=ndig[1]=ndig[2]=0;
zero=0;
for (a=strlen(s)-1; a>=0; a--)
{
if ((s[a]=='0') && (!zero))
zero=1;
else
{
assert(s[a]>=48);
b=(s[a]-'0')%3;
dig[b][ndig[b]++]=s[a];
}
}
//sort
for (a=0; a<3; a++)
sort(dig[a],dig[a]+ndig[a]);
nout=0;
//find last digit
if (!zero)
{
//no 0s, so look for a 5
for (a=0; a<ndig[2]; a++)
{
if (dig[2][a]=='5')
{
//take the 5
memmove(dig[2]+a,dig[2]+a+1,sizeof(int)*(ndig[2]-a-1));
ndig[2]--;
//take other digits to cancel it out
if ((ndig[1]>0) && (fox(ndig[1]-1,ndig[2])>fox(ndig[1],ndig[2]-2)))
{
out[nout++]=dig[1][--ndig[1]];
}
else
if (ndig[2]>1)
{
out[nout++]=dig[2][--ndig[2]];
out[nout++]=dig[2][--ndig[2]];
}
else
goto bad;
goto ok;
}
}
//no 0s or 5s
bad:
printf("impossible\n");
continue;
}
ok:
//use as many digits as possible
for (a=0; a<ndig[0]; a++)
{
out[nout++]=dig[0][a];
}
while ((ndig[1]>2) && (ndig[1]>ndig[2]+1))
for (a=0; a<3; a++)
{
out[nout++]=dig[1][--ndig[1]];
}
while ((ndig[2]>2) && (ndig[2]>ndig[1]+1))
for (a=0; a<3; a++)
{
out[nout++]=dig[2][--ndig[2]];
}
for (a=min(ndig[1],ndig[2]); a--; )
{
out[nout++]=dig[1][--ndig[1]];
out[nout++]=dig[2][--ndig[2]];
}
//sort and output
if (nout<1)
goto grr;
sort(out,out+nout);
if (out[nout-1]=='0')
{
grr:
printf("0\n");
continue;
}
for (a=nout-1; a>=0; a--)
{
printf("%c",out[a]);
}
if (zero)
printf("0\n");
else
printf("5\n");
}
}
| 17.654412
| 76
| 0.436068
|
ohmyjons
|
f72d8543b64197c6934345431ce573faf6340eb6
| 2,290
|
cpp
|
C++
|
PE/ch13/13.2/classic.cpp
|
DustOfStars/CppPrimerPlus6
|
391e3ad76eaa99f331981cee72139d83115fc93d
|
[
"MIT"
] | null | null | null |
PE/ch13/13.2/classic.cpp
|
DustOfStars/CppPrimerPlus6
|
391e3ad76eaa99f331981cee72139d83115fc93d
|
[
"MIT"
] | null | null | null |
PE/ch13/13.2/classic.cpp
|
DustOfStars/CppPrimerPlus6
|
391e3ad76eaa99f331981cee72139d83115fc93d
|
[
"MIT"
] | null | null | null |
#include <iostream>
#include <cstring>
#include "classic.h"
using namespace std;
// Cd methods
Cd::Cd(const char * s1, const char * s2, int n, double x)
{
performers = new char[strlen(s1)+1];
strcpy(performers, s1);
label = new char[strlen(s2)+1];
strcpy(label, s2);
selections = n;
playtime = x;
}
Cd::Cd(const Cd & d)
{
performers = new char[strlen(d.performers)+1];
strcpy(performers, d.performers);
label = new char[strlen(d.label)+1];
strcpy(label, d.label);
selections = d.selections;
playtime = d.playtime;
}
Cd::Cd()
{
performers = new char[8];
strcpy(performers, "Unknown");
label = new char[5];
strcpy(label, "None");
selections = 0;
playtime = 0.0;
}
Cd::~Cd()
{
delete [] performers;
delete [] label;
}
void Cd::Report() const
{
cout << "Performers: " << performers << endl;
cout << "Label: " << label << endl;
cout << selections << " selections, " << playtime << " minutes.\n";
}
Cd & Cd::operator=(const Cd & d)
{
if (this == &d)
return *this;
delete [] performers;
performers = new char[strlen(d.performers) + 1];
strcpy(performers, d.performers);
delete [] label;
label = new char[strlen(d.label) + 1];
strcpy(label, d.label);
selections = d.selections;
playtime = d.playtime;
return *this;
}
// Classic methods
Classic::Classic(const char * pri, const char * per, const char * l,
int n, double x) : Cd(per, l, n, x)
{
primary = new char[strlen(pri)+1];
strcpy(primary, pri);
}
Classic::Classic(const Cd & d, const char * pri) : Cd(d)
{
primary = new char[strlen(pri)+1];
strcpy(primary, pri);
}
Classic::Classic(const Classic & c) : Cd(c)
{
primary = new char[strlen(c.primary)+1];
strcpy(primary, c.primary);
}
Classic::Classic() : Cd()
{
primary = new char[5];
strcpy(primary, "None");
}
Classic::~Classic()
{
delete [] primary;
}
void Classic::Report() const
{
cout << "Primary work: " << primary << endl;
Cd::Report();
}
Classic & Classic::operator=(const Classic & d)
{
if (this == &d)
return *this;
Cd::operator=(d);
delete [] primary;
primary = new char[strlen(d.primary)+1];
strcpy(primary, d.primary);
return *this;
}
| 20.446429
| 71
| 0.588646
|
DustOfStars
|
f72fce116b96a5bf3d94f0639e9f3219bca7b8fa
| 505
|
cpp
|
C++
|
shared/ADM/Physics/PhysBody_Box.cpp
|
BlueNightHawk4906/HL-ADM-Custom
|
7cd3925de819d4f5a2a808e5c0b34bb03a51c991
|
[
"Unlicense"
] | 1
|
2020-12-11T17:52:33.000Z
|
2020-12-11T17:52:33.000Z
|
shared/ADM/Physics/PhysBody_Box.cpp
|
BlueNightHawk4906/HL-ADM-Custom
|
7cd3925de819d4f5a2a808e5c0b34bb03a51c991
|
[
"Unlicense"
] | 7
|
2021-07-09T09:19:14.000Z
|
2021-07-20T19:35:21.000Z
|
shared/ADM/Physics/PhysBody_Box.cpp
|
phoenixprojectsoftware/phoenixADM
|
5f170a34739e64111dbe161d9ab9e0baa219512b
|
[
"Unlicense"
] | null | null | null |
#include "Base/ExtDLL.h"
#include "Util.h"
#include "Base/CBase.h"
#include "IPhysBody.h"
#include "PhysBody.h"
#include "PhysBody_Box.h"
/*
========================================================
CPhysBody_Box
========================================================
*/
void CPhysBody_Box::InitShape( const PhysParameters& params )
{
btVector3 btExtents( params.dimensions.x, params.dimensions.z, params.dimensions.y );
shape = new btBoxShape( PhysUtils::utom(btExtents) );
}
| 24.047619
| 87
| 0.540594
|
BlueNightHawk4906
|
f731610d79f73bcac7579b85309615dbfc340a2d
| 2,759
|
cpp
|
C++
|
src/examples/ex-ndpomdp.cpp
|
SDMStudio/sdms
|
43a86973081ffd86c091aed69b332f0087f59361
|
[
"MIT"
] | null | null | null |
src/examples/ex-ndpomdp.cpp
|
SDMStudio/sdms
|
43a86973081ffd86c091aed69b332f0087f59361
|
[
"MIT"
] | null | null | null |
src/examples/ex-ndpomdp.cpp
|
SDMStudio/sdms
|
43a86973081ffd86c091aed69b332f0087f59361
|
[
"MIT"
] | null | null | null |
#include <iostream>
#include <memory>
#include <sdm/exception.hpp>
#include <sdm/config.hpp>
#include <sdm/parser/parser.hpp>
using namespace sdm;
int main(int argc, char **argv)
{
std::string ndpomdp_filename = (argc > 1) ? argv[1] : config::PROBLEM_PATH + "dpomdp/tiger.dpomdp";
// Instanciate a standard MPOMDP from a ".ndpomdp" file
std::cout << "----------------------------------------" << std::endl;
std::cout << "#> Instanciate a MPOMDP (from a NDPOMDP file)" << std::endl;
std::cout << "----------------------------------------" << std::endl;
std::shared_ptr<MPOMDP> mpomdp_from_ndpomdp = sdm::parser::parse_file(ndpomdp_filename);
mpomdp_from_ndpomdp->setHorizon(2);
// --------------------------------------------------
// ----------- DISPLAY SOME ATTRIBUTES --------------
// --------------------------------------------------
std::cout << "#> Description of the problem" << std::endl;
std::cout << "----------------------------------------" << std::endl;
std::cout << "#> Horizon=" << mpomdp_from_ndpomdp->getHorizon() << std::endl;
std::cout << "----------------------------------------" << std::endl;
std::cout << "\033[1;31m#> STATE SPACE (standard version)\033[0m" << std::endl;
std::cout << *mpomdp_from_ndpomdp->getStateSpace(0) << std::endl;
std::cout << "----------------------------------------" << std::endl;
std::cout << "\033[1;31m#> ACTION SPACE (standard version)\033[0m" << std::endl;
std::cout << *mpomdp_from_ndpomdp->getActionSpace(0) << std::endl;
std::cout << "----------------------------------------" << std::endl;
std::cout << "\033[1;31m#> OBSERVATION SPACE (standard version)\033[0m" << std::endl;
std::cout << *mpomdp_from_ndpomdp->getObservationSpace(0) << std::endl;
std::cout << "----------------------------------------" << std::endl;
std::cout << "\033[1;31m#> REWARD (standard version)\033[0m" << std::endl;
for (const auto &s : *mpomdp_from_ndpomdp->getStateSpace(0))
{
for (const auto &a : *mpomdp_from_ndpomdp->getActionSpace(0))
{
std::cout << "R(" << *s << ", " << *a << ")=" << mpomdp_from_ndpomdp->getReward(s->toState(), a->toAction()) << std::endl;
}
}
// std::cout << "----------------------------------------" << std::endl;
// std::cout << "\033[1;31m#> TRANSITION (standard version)\033[0m" << std::endl;
// for (const auto &s : *mpomdp_from_ndpomdp->getStateSpace(0))
// {
// for (const auto &a : *mpomdp_from_ndpomdp->getActionSpace(0))
// {
// std::cout << "R(" << *s << ", " << *a << ")=" << mpomdp_from_ndpomdp->getReward(s->toState(), a->toAction()) << std::endl;
// }
// }
} // END main
| 47.568966
| 137
| 0.485321
|
SDMStudio
|
f73502070122fc25d034257d86eb5cf344fd3b39
| 5,154
|
cpp
|
C++
|
Soomla/NativeImpl/CCNativeVirtualCurrencyStorage.cpp
|
konopka/cocos2dx-store
|
9646c4d474e4416d8dde637b54100d2bfd30741d
|
[
"Apache-2.0"
] | null | null | null |
Soomla/NativeImpl/CCNativeVirtualCurrencyStorage.cpp
|
konopka/cocos2dx-store
|
9646c4d474e4416d8dde637b54100d2bfd30741d
|
[
"Apache-2.0"
] | null | null | null |
Soomla/NativeImpl/CCNativeVirtualCurrencyStorage.cpp
|
konopka/cocos2dx-store
|
9646c4d474e4416d8dde637b54100d2bfd30741d
|
[
"Apache-2.0"
] | 3
|
2020-05-10T08:41:59.000Z
|
2021-02-11T15:58:32.000Z
|
/*
Copyright (C) 2012-2014 Soomla Inc.
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 "CCNativeVirtualCurrencyStorage.h"
#include "CCNativeVirtualGoodsStorage.h"
#include "CCSoomlaUtils.h"
#include "CCNdkBridge.h"
#include "CCStoreInfo.h"
#include "CCUpgradeVG.h"
namespace soomla {
#define TAG "SOOMLA NativeVirtualCurrencyStorage"
USING_NS_CC;
CCNativeVirtualCurrencyStorage::CCNativeVirtualCurrencyStorage() {
}
CCNativeVirtualCurrencyStorage::~CCNativeVirtualCurrencyStorage() {
}
int CCNativeVirtualCurrencyStorage::getBalance(CCVirtualItem *item, CCError **error) {
const char *itemId = item->getId()->getCString();
CCSoomlaUtils::logDebug(TAG,
__String::createWithFormat("SOOMLA/COCOS2DX Calling getBalance with: %s", itemId)->getCString());
__Dictionary *params = __Dictionary::create();
params->setObject(__String::create("CCNativeVirtualCurrencyStorage::getBalance"), "method");
params->setObject(__String::create(itemId), "itemId");
__Dictionary *retParams = (__Dictionary *) CCNdkBridge::callNative (params, error);
if (retParams == NULL) {
return 0;
}
__Integer *retValue = (__Integer *) retParams->objectForKey("return");
if (retValue) {
return retValue->getValue();
} else {
return 0;
}
}
int CCNativeVirtualCurrencyStorage::setBalance(CCVirtualItem *item, int balance, bool notify, CCError **error) {
const char *itemId = item->getId()->getCString();
CCSoomlaUtils::logDebug(TAG,
__String::createWithFormat("SOOMLA/COCOS2DX Calling setBalance with: %s", itemId)->getCString());
__Dictionary *params = __Dictionary::create();
params->setObject(__String::create("CCNativeVirtualCurrencyStorage::setBalance"), "method");
params->setObject(__String::create(itemId), "itemId");
params->setObject(__Integer::create(balance), "balance");
params->setObject(__Bool::create(notify), "notify");
__Dictionary *retParams = (__Dictionary *) CCNdkBridge::callNative (params, error);
if (retParams == NULL) {
return 0;
}
__Integer *retValue = (__Integer *) retParams->objectForKey("return");
if (retValue) {
return retValue->getValue();
} else {
return 0;
}
}
int CCNativeVirtualCurrencyStorage::add(CCVirtualItem *item, int amount, bool notify, CCError **error) {
const char *itemId = item->getId()->getCString();
CCSoomlaUtils::logDebug(TAG,
__String::createWithFormat("SOOMLA/COCOS2DX Calling add with: %s", itemId)->getCString());
__Dictionary *params = __Dictionary::create();
params->setObject(__String::create("CCNativeVirtualCurrencyStorage::add"), "method");
params->setObject(__String::create(itemId), "itemId");
params->setObject(__Integer::create(amount), "amount");
params->setObject(__Bool::create(notify), "notify");
__Dictionary *retParams = (__Dictionary *) CCNdkBridge::callNative (params, error);
if (retParams == NULL) {
return 0;
}
__Integer *retValue = (__Integer *) retParams->objectForKey("return");
if (retValue) {
return retValue->getValue();
} else {
return 0;
}
}
int CCNativeVirtualCurrencyStorage::remove(CCVirtualItem *item, int amount, bool notify, CCError **error) {
const char *itemId = item->getId()->getCString();
CCSoomlaUtils::logDebug(TAG,
__String::createWithFormat("SOOMLA/COCOS2DX Calling remove with: %s", itemId)->getCString());
__Dictionary *params = __Dictionary::create();
params->setObject(__String::create("CCNativeVirtualCurrencyStorage::remove"), "method");
params->setObject(__String::create(itemId), "itemId");
params->setObject(__Integer::create(amount), "amount");
params->setObject(__Bool::create(notify), "notify");
__Dictionary *retParams = (__Dictionary *) CCNdkBridge::callNative (params, error);
if (retParams == NULL) {
return 0;
}
__Integer *retValue = (__Integer *) retParams->objectForKey("return");
if (retValue) {
return retValue->getValue();
} else {
return 0;
}
}
}
| 39.343511
| 129
| 0.624175
|
konopka
|
f73861850e378e2a14db6b20966fcf67fc24ee10
| 316
|
cpp
|
C++
|
LibApophis/src/Training/StoppingConditions.cpp
|
elpollouk/Apophis
|
a400a3d689750502137b048eef8e8246f7c04d6b
|
[
"MIT"
] | null | null | null |
LibApophis/src/Training/StoppingConditions.cpp
|
elpollouk/Apophis
|
a400a3d689750502137b048eef8e8246f7c04d6b
|
[
"MIT"
] | null | null | null |
LibApophis/src/Training/StoppingConditions.cpp
|
elpollouk/Apophis
|
a400a3d689750502137b048eef8e8246f7c04d6b
|
[
"MIT"
] | null | null | null |
#include "stdafx.h"
#include "apophis/Training/StoppingConditions.h"
using namespace Apophis;
using namespace Apophis::Training::StoppingCondition;
bool AnyStoppingCondition::Check(Data::Metrics& metrics) const
{
for (auto& condition : m_Conditions)
if ((*condition)(metrics))
return true;
return false;
}
| 21.066667
| 62
| 0.762658
|
elpollouk
|
f73dac4d5c6b9d0cecd7064ebf6cf5e63c739d00
| 2,225
|
cc
|
C++
|
gcc-gcc-7_3_0-release/libstdc++-v3/testsuite/18_support/type_info/hash_code.cc
|
best08618/asylo
|
5a520a9f5c461ede0f32acc284017b737a43898c
|
[
"Apache-2.0"
] | 7
|
2020-05-02T17:34:05.000Z
|
2021-10-17T10:15:18.000Z
|
gcc-gcc-7_3_0-release/libstdc++-v3/testsuite/18_support/type_info/hash_code.cc
|
best08618/asylo
|
5a520a9f5c461ede0f32acc284017b737a43898c
|
[
"Apache-2.0"
] | null | null | null |
gcc-gcc-7_3_0-release/libstdc++-v3/testsuite/18_support/type_info/hash_code.cc
|
best08618/asylo
|
5a520a9f5c461ede0f32acc284017b737a43898c
|
[
"Apache-2.0"
] | 2
|
2020-07-27T00:22:36.000Z
|
2021-04-01T09:41:02.000Z
|
// { dg-do run { target c++11 } }
// 2010-09-21 Paolo Carlini <paolo.carlini@oracle.com>
//
// Copyright (C) 2010-2017 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <typeinfo>
#include <testsuite_hooks.h>
void test01()
{
using namespace std;
class Abraca { };
Abraca a1, a2_;
typedef const Abraca cAbraca;
cAbraca a2 = a2_;
class Dabra { };
Dabra d1;
const type_info& to01 = typeid(int);
const type_info& to02 = typeid(double);
VERIFY( to01 != to02 );
VERIFY( to01.hash_code() != to02.hash_code() );
const type_info& to03 = typeid(a1);
const type_info& to04 = typeid(a2);
VERIFY( to03 == to04 );
VERIFY( to03.hash_code() == to04.hash_code() );
const type_info& to05 = typeid(Abraca);
const type_info& to06 = typeid(cAbraca);
VERIFY( to05 == to06 );
VERIFY( to05.hash_code() == to06.hash_code() );
const type_info& to07 = typeid(Abraca);
const type_info& to08 = typeid(a2);
VERIFY( to07 == to08 );
VERIFY( to07.hash_code() == to08.hash_code() );
const type_info& to09 = typeid(Abraca);
const type_info& to10 = typeid(const Abraca&);
VERIFY( to09 == to10 );
VERIFY( to09.hash_code() == to10.hash_code() );
const type_info& to11 = typeid(Abraca);
const type_info& to12 = typeid(Dabra);
VERIFY( to11 != to12 );
VERIFY( to11.hash_code() != to12.hash_code() );
const type_info& to13 = typeid(a1);
const type_info& to14 = typeid(d1);
VERIFY( to13 != to14 );
VERIFY( to13.hash_code() != to14.hash_code() );
}
int main()
{
test01();
return 0;
}
| 28.164557
| 74
| 0.678652
|
best08618
|
f73e40dae92f93bf31a9ffc7c25942b7a6c932f2
| 623
|
cc
|
C++
|
src/stb_gl.cc
|
stbd/stoolbox
|
4535e1df2795cb0157420e7d4b1a01f3bda441da
|
[
"MIT"
] | null | null | null |
src/stb_gl.cc
|
stbd/stoolbox
|
4535e1df2795cb0157420e7d4b1a01f3bda441da
|
[
"MIT"
] | null | null | null |
src/stb_gl.cc
|
stbd/stoolbox
|
4535e1df2795cb0157420e7d4b1a01f3bda441da
|
[
"MIT"
] | null | null | null |
#include "stb_gl.hh"
#include "stb_types.hh"
#include "stb_error.hh"
namespace stb {
extern void setError(const char * format, ...);
}
GLenum stb::getGlError(const char * file, const int lineNumber)
{
GLenum glError = glGetError();
if (glError != GL_NO_ERROR) {
stb::setError("GL error: %d at %s:%d\n", glError, file, lineNumber);
}
return glError;
}
static_assert(sizeof(GLuint) == sizeof(GL_U),
"Assumption failed: Size of GLuint and GL_U is not equal");
static_assert(sizeof(GLint) == sizeof(GL_I),
"Assumption failed: Size of GLuint and GL_I is not equal");
| 25.958333
| 76
| 0.651685
|
stbd
|
f743e3fb5bebbcaa5717dbebd67d3a094b7d61a6
| 1,701
|
hpp
|
C++
|
PotreeConverter/include/PointAttributes.hpp
|
tigerfoot/PotreeConverter
|
75cbd0e8b75995b2806e4b7bda03369c6ed2605d
|
[
"BSD-2-Clause-FreeBSD"
] | null | null | null |
PotreeConverter/include/PointAttributes.hpp
|
tigerfoot/PotreeConverter
|
75cbd0e8b75995b2806e4b7bda03369c6ed2605d
|
[
"BSD-2-Clause-FreeBSD"
] | null | null | null |
PotreeConverter/include/PointAttributes.hpp
|
tigerfoot/PotreeConverter
|
75cbd0e8b75995b2806e4b7bda03369c6ed2605d
|
[
"BSD-2-Clause-FreeBSD"
] | null | null | null |
#ifndef POINT_ATTRIBUTES_H
#define POINT_ATTRIBUTES_H
#include <string>
#include <vector>
using std::string;
using std::vector;
class PointAttribute{
public:
static const PointAttribute POSITION_CARTESIAN;
static const PointAttribute COLOR_PACKED;
int ordinal;
string name;
int numElements;
int byteSize;
PointAttribute(int ordinal, string name, int numElements, int byteSize){
this->ordinal = ordinal;
this->name = name;
this->numElements = numElements;
this->byteSize = byteSize;
}
//bool operator==(const PointAttribute &other){
// return ordinal == other.ordinal;
//}
};
bool operator==(const PointAttribute& lhs, const PointAttribute& rhs);
//class PointAttributeDef{
//public:
// string name;
// int numElements;
// int byteSize;
//
// PointAttributeDef(string name, int numElements, int byteSize){
// this->name = name;
// this->numElements = numElements;
// this->byteSize = byteSize;
// }
//};
//
//namespace PointAttribute{
// PointAttributeDef POSITION_CARTESIAN("POSITION_CARTESIAN", 3, 3*sizeof(float));
// PointAttributeDef COLOR_PACKED("COLOR_PACKED", 4, 4*sizeof(unsigned char));
//}
//struct PointAttribute{
// const PointAttributeDef POSITION_CARTESIAN("POSITION_CARTESIAN", 3, 3*sizeof(float));
// const PointAttributeDef COLOR_PACKED("COLOR_PACKED", 4, 4*sizeof(unsigned char));
//};
class PointAttributes{
public:
vector<PointAttribute> attributes;
int byteSize;
PointAttributes(){
byteSize = 0;
}
void add(PointAttribute attribute){
attributes.push_back(attribute);
byteSize += attribute.byteSize;
}
int size(){
return attributes.size();
}
PointAttribute& operator[](int i) {
return attributes[i];
}
};
#endif
| 18.692308
| 88
| 0.724868
|
tigerfoot
|
f748be09efae8224601c0d90ab2cca51fba05c8e
| 14,950
|
cpp
|
C++
|
src/crypt.cpp
|
icedac/nativecoin-cpp
|
cc5ea9c9dfc7e8974f3b580cbb3767354d0b9b78
|
[
"BSL-1.0",
"BSD-3-Clause",
"OpenSSL",
"MIT"
] | null | null | null |
src/crypt.cpp
|
icedac/nativecoin-cpp
|
cc5ea9c9dfc7e8974f3b580cbb3767354d0b9b78
|
[
"BSL-1.0",
"BSD-3-Clause",
"OpenSSL",
"MIT"
] | null | null | null |
src/crypt.cpp
|
icedac/nativecoin-cpp
|
cc5ea9c9dfc7e8974f3b580cbb3767354d0b9b78
|
[
"BSL-1.0",
"BSD-3-Clause",
"OpenSSL",
"MIT"
] | null | null | null |
/****************************************************************************
*
* crypt.cpp
* ($\nativecoin-cpp\src)
*
* by icedac
*
***/
#include "stdafx.h"
#include "nc.h"
#include "crypt.h"
#include "util.h"
#include <mutex>
#include <openssl/evp.h>
#include <openssl/ecdsa.h>
#include <openssl/bn.h>
#ifdef _WIN64
#pragma comment( lib, "libeay32_x64.lib" )
#pragma comment( lib, "ssleay32_x64.lib" )
#else
#pragma comment( lib, "libeay32_x86.lib" )
#pragma comment( lib, "ssleay32_x86.lib" )
#endif
namespace nc {
namespace crypt {
// openssl crypto library c++ wrapper
// manual: https://www.openssl.org/docs/man1.0.2/crypto/
// very clumpsy and almost no example :-(
namespace internal {
// msg_digest_ctx
class md_ctx {
public:
friend class md;
md_ctx() {
ctx_ = EVP_MD_CTX_create();
}
~md_ctx() {
if (ctx_)
{
EVP_MD_CTX_destroy(ctx_);
}
}
md_ctx(const md_ctx&) = delete;
md_ctx& operator = (const md_ctx&) = delete;
md_ctx(md_ctx&& rhs) noexcept : ctx_(rhs.ctx_) {
rhs.ctx_ = nullptr;
}
md_ctx& operator = (md_ctx&& rhs) noexcept {
ctx_ = rhs.ctx_;
rhs.ctx_ = nullptr;
}
public:
void update(gsl::span< const byte > v) {
EVP_DigestUpdate(ctx_, v.data(), v.size());
}
auto get() {
vector< byte > hash(EVP_MAX_MD_SIZE);
unsigned int len = 0;
EVP_DigestFinal_ex(ctx_, const_cast<byte*>(hash.data()), &len);
hash.resize(len);
return hash;
}
private:
EVP_MD_CTX* ctx_ = nullptr;
};
// msg_digest
class md {
public:
md() {}
md(const md&) = delete;
md& operator = (const md&) = delete;
md(md&& rhs) noexcept : md_(rhs.md_) {
rhs.md_ = nullptr;
}
md& operator = (md&& rhs) noexcept {
md_ = rhs.md_;
rhs.md_ = nullptr;
}
md_ctx create_ctx() {
md_ctx c;
EVP_DigestInit_ex(c.ctx_, md_, nullptr);
return c;
}
operator bool() const {
if (md_) return true;
return false;
}
public:
static md from_name(string md_name) {
md m;
m.md_ = EVP_get_digestbyname(md_name.c_str());
return m;
}
private:
const EVP_MD* md_ = nullptr;
};
// ec_key
//
// BIGNUM used for Private Key
// EC_POINT used for Public Key and can be caculated from Private Key
// @see load_private_key_from_hex() for calculation
class ec_key {
public:
enum ec_curve_name_t {
SECP256K1 = NID_secp256k1
};
ec_key() {}
~ec_key() {
if (ec_)
EC_KEY_free(ec_);
}
ec_key(const ec_key&) = delete;
ec_key& operator = (const ec_key&) = delete;
ec_key(ec_key&& rhs) noexcept : ec_(rhs.ec_) {
rhs.ec_ = nullptr;
}
ec_key& operator = (ec_key&& rhs) noexcept {
ec_ = rhs.ec_;
rhs.ec_ = nullptr;
}
bool generate_key() {
if (!EC_KEY_generate_key(ec_)) return false;
return true;
}
auto get_private_key() const {
const BIGNUM* priv = EC_KEY_get0_private_key(ec_);
char* priv_key = BN_bn2hex(priv);
// printf("priv: %s\n", priv_key);
std::string priv_str = priv_key;
OPENSSL_free(priv_key);
return priv_str;
}
auto get_public_key() const {
const EC_POINT* pub = EC_KEY_get0_public_key(ec_);
char* pub_key = EC_POINT_point2hex(EC_KEY_get0_group(ec_), pub, POINT_CONVERSION_UNCOMPRESSED, NULL);
// printf("pub: %s\n", pub_key);
std::string pub_str = pub_key;
OPENSSL_free(pub_key);
return pub_str;
}
bool load_public_key_from_hex(string hex) {
const auto* group = EC_KEY_get0_group(ec_);
BN_CTX* ctx = BN_CTX_new();
EC_POINT* pub = EC_POINT_new(group);
EC_POINT_hex2point(group, hex.c_str(), pub, ctx);
EC_KEY_set_public_key(ec_, pub);
// FIXME: donno ownership transfer or not from EC_KEY_set_public_key(), so it can be crash
// openssl documentation is clumpsy - https://www.openssl.org/docs/man1.0.2/crypto/EC_KEY_set_public_key.html
EC_POINT_free(pub);
BN_CTX_free(ctx);
return true;
}
// also calculate pub key and set it
bool load_private_key_from_hex(string hex) {
BIGNUM start;
BN_init(&start);
BN_CTX* ctx = BN_CTX_new();
BIGNUM* priv = &start;
BN_hex2bn(&priv, hex.c_str());
const auto* group = EC_KEY_get0_group(ec_);
EC_POINT* pub = EC_POINT_new(group);
EC_KEY_set_private_key(ec_, priv);
if (!EC_POINT_mul(group, pub, priv, nullptr, nullptr, ctx))
{
std::cout << "EC_POINT_mul() failed\n";
return false;
}
EC_KEY_set_public_key(ec_, pub);
// FIXME: donno ownership transfer or not from EC_KEY_set_public_key(), so it can be crash
// openssl documentation is clumpsy - https://www.openssl.org/docs/man1.0.2/crypto/EC_KEY_set_public_key.html
EC_POINT_free(pub);
BN_CTX_free(ctx);
return true;
}
// sign()
//
// sign data and return DER encoded
//
vector<byte> sign(gsl::span< const byte > v) {
// FIXME: need to check and manage ownership of 'sig'
ECDSA_SIG* sig;
sig = ECDSA_do_sign(v.data(), (int)v.size(), ec_);
if (!sig) {
return vector< byte >();
}
vector< byte > der_sign(128);
int len = i2d_ECDSA_SIG(sig, nullptr);
der_sign.reserve(len + 1);
byte* der_sign_buf = const_cast<byte*>(der_sign.data());
len = i2d_ECDSA_SIG(sig, (byte**)&der_sign_buf);
der_sign.resize(len);
return der_sign;
}
// verify
//
// verify from data and DER encoded
//
bool verify(gsl::span< const byte > v, vector<byte> der_sign) {
const byte* der_sign_buf = der_sign.data();
ECDSA_SIG* sig = ECDSA_SIG_new();
ECDSA_SIG* ok_sig = d2i_ECDSA_SIG(&sig, &der_sign_buf, (int)der_sign.size());
if (!ok_sig) {
auto der_sign_str = util::binary_to_hexstring(der_sign);
std::cout << "wrong signature: " << der_sign_str << "\n";
return false;
}
int ret = ECDSA_do_verify(v.data(), (int)v.size(), ok_sig, ec_);
ECDSA_SIG_free(sig);
if (ret == 0) {
std::cout << "incorrect signature\n";
return false;
}
else if (ret == 1)
{
return true;
}
std::cout << "error: ret: " << ret << "\n";
return false;
}
public:
static ec_key from_curve(ec_curve_name_t ec_curve_name) {
ec_key key;
key.ec_ = EC_KEY_new_by_curve_name((int)ec_curve_name);
return key;
}
private:
EC_KEY* ec_ = nullptr;
};
void run_at_exit() {
EVP_cleanup();
}
static std::once_flag s_openssl_init;
void init_main__() {
OpenSSL_add_all_digests();
using internal::ec_key;
if (0)
{
ec_key ec = ec_key::from_curve(ec_key::SECP256K1);
ec.generate_key();
auto pub_str = ec.get_public_key();
std::cout << "pub_key: " << pub_str << "\n";
auto priv_str = ec.get_private_key();
std::cout << "priv_key: " << priv_str << "\n";
}
// priv_key : D7CB4C0ABF38327AC93829E889906D98A7D2BD24D95DF58C72BC2AE8C168AB0E
// pub_key: 04FAE9D499739BDCB475F746C35AA931BFF8F9448395F12C09E445546E2B9958681693E480FB6379D5F9645F970E7154359EFFCC6C8C150B04CCB86EA31B9062D3
if (0)
{
ec_key ec = ec_key::from_curve(ec_key::SECP256K1);
ec.load_private_key_from_hex("D7CB4C0ABF38327AC93829E889906D98A7D2BD24D95DF58C72BC2AE8C168AB0E");
// ec.load_public_key_from_hex("04FAE9D499739BDCB475F746C35AA931BFF8F9448395F12C09E445546E2B9958681693E480FB6379D5F9645F970E7154359EFFCC6C8C150B04CCB86EA31B9062D3");
auto pub_str = ec.get_public_key();
std::cout << "pub_key: " << pub_str << "\n";
// priv_str = ec2.get_private_key();
// std::cout << "priv_key: " << priv_str << "\n";
auto str = string("12345678901234567890");
const byte* data = reinterpret_cast<const byte*>(str.data());
auto der_sign = ec.sign({ data, data + str.size() });
auto der_sign_str = util::binary_to_hexstring(der_sign);
}
// high-level
if (0)
{
// sign
auto priv_key = nc::ecdsa_key("D7CB4C0ABF38327AC93829E889906D98A7D2BD24D95DF58C72BC2AE8C168AB0E");
auto str = string("12345678901234567890");
auto der_sign_str = nc::crypt::sign(priv_key, str);
// verify
auto pub_key = "04FAE9D499739BDCB475F746C35AA931BFF8F9448395F12C09E445546E2B9958681693E480FB6379D5F9645F970E7154359EFFCC6C8C150B04CCB86EA31B9062D3";
bool verified = nc::crypt::verify(ecdsa_address(pub_key), str, der_sign_str);
if (verified) {
std::cout << "[VERIFIED] ok\n";
}
else
{
std::cout << "[<FAILED> to VERIFY]\n";
}
}
std::atexit(nc::crypt::internal::run_at_exit);
}
void init_() {
std::call_once(s_openssl_init, []() {
init_main__();
});
}
} // namespace internal {
}
namespace crypt {
sha256_hash sha256(string str)
{
internal::init_();
using internal::md;
auto md_sha256 = md::from_name("sha256");
if (!md_sha256) return nc::sha256_hash::from_string("md_sha256 not found");
auto ctx = md_sha256.create_ctx();
const byte* data = reinterpret_cast<const byte*>(str.data());
ctx.update({ data, data + str.size() });
auto hash = ctx.get();
return nc::sha256_hash::from_string(util::binary_to_hexstring(hash));
}
ecdsa_key generate_private_key()
{
using internal::ec_key;
ec_key ec = ec_key::from_curve(ec_key::SECP256K1);
if (!ec.generate_key()) return "";
return ec.get_private_key();
}
ecdsa_address get_address(const ecdsa_key& priv_key)
{
using internal::ec_key;
ec_key ec = ec_key::from_curve(ec_key::SECP256K1);
ec.load_private_key_from_hex(priv_key.get());
return nc::ecdsa_address{ ec.get_public_key() };
}
ecdsa_signature sign(const ecdsa_key& priv_key, const string& str)
{
using internal::ec_key;
ec_key ec = ec_key::from_curve(ec_key::SECP256K1);
ec.load_private_key_from_hex(priv_key.get());
const byte* data = reinterpret_cast<const byte*>(str.data());
auto der_sign = ec.sign({ data, data + str.size() });
auto der_sign_str = util::binary_to_hexstring(der_sign);
return der_sign_str;
}
bool verify(const ecdsa_address& addr, const string& str, const ecdsa_signature& signature)
{
using internal::ec_key;
ec_key ec = ec_key::from_curve(ec_key::SECP256K1);
ec.load_public_key_from_hex(addr.get());
const byte* data = reinterpret_cast<const byte*>(str.data());
auto der_sign = util::hexstring_to_binary(signature.get());
return ec.verify({ data, data + str.size() }, der_sign);
}
}
}
| 34.288991
| 186
| 0.449632
|
icedac
|
f748e0c54ec5a9c0acd204c14fee434c7c4b5484
| 110
|
cpp
|
C++
|
doc/my_notes/image_manipulation.cpp
|
felixchenfy/cpp_practice_image_processing
|
72724097e3d9d35eb813fc04aac56d79419d6c7d
|
[
"MIT"
] | 4
|
2019-12-23T09:44:51.000Z
|
2021-08-07T05:20:24.000Z
|
doc/my_notes/image_manipulation.cpp
|
felixchenfy/cpp_practice_image_processing
|
72724097e3d9d35eb813fc04aac56d79419d6c7d
|
[
"MIT"
] | null | null | null |
doc/my_notes/image_manipulation.cpp
|
felixchenfy/cpp_practice_image_processing
|
72724097e3d9d35eb813fc04aac56d79419d6c7d
|
[
"MIT"
] | 2
|
2020-04-01T02:11:54.000Z
|
2020-08-18T12:48:06.000Z
|
/**
* Split color image into three channels.
*/
std::vector<cv::Mat> three_channels = cv::split(img);
| 10
| 53
| 0.636364
|
felixchenfy
|
f74cf9a4bc2fa11b0240ded3c4cfcbcc10a00e91
| 1,485
|
cpp
|
C++
|
Esercizi/Classi/Gelato/main.cpp
|
gabrielegenovese/Esercizi-Programmazione-2020
|
bb16aec872ece3f7d88fcbfc88b3778efcb4f16b
|
[
"MIT"
] | null | null | null |
Esercizi/Classi/Gelato/main.cpp
|
gabrielegenovese/Esercizi-Programmazione-2020
|
bb16aec872ece3f7d88fcbfc88b3778efcb4f16b
|
[
"MIT"
] | null | null | null |
Esercizi/Classi/Gelato/main.cpp
|
gabrielegenovese/Esercizi-Programmazione-2020
|
bb16aec872ece3f7d88fcbfc88b3778efcb4f16b
|
[
"MIT"
] | null | null | null |
#include <iostream>
#include <cstring>
using namespace std;
# define cono 2.70
# define cestina 2.50
# define coppetta 2
struct gusto
{
char nome[10];
};
typedef gusto *p_gusto;
class Gelato
{
protected:
p_gusto gusti[3];
int cursor;
double tipo;
public:
void aggiungiGelato(char g[])
{
int i = 0;
while(this->gusti[i] != NULL && i < 3)
i++;
if(i == 3)
cout << "Limite di gusti raggiunto\n";
else
{
this->gusti[i] = new gusto;
strcpy(this->gusti[i]->nome,g);
}
}
double calcolaPrezzo()
{
return tipo;
}
Gelato(double tipo = 0)
{
for (int i = 0; i < 3; i++)
this->gusti[i] = NULL;
this->cursor = 0;
this->tipo = tipo;
}
};
class Cono : public Gelato
{
public:
Cono() : Gelato(cono){}
};
class Cestina : public Gelato
{
public:
Cestina() : Gelato(cestina){}
};
class Coppetta : public Gelato
{
Coppetta() : Gelato(coppetta){}
};
int main()
{
Cono g1 = Cono();
g1.aggiungiGelato((char*)"Fragola");
g1.aggiungiGelato((char*)"Cioccolato");
g1.aggiungiGelato((char*)"Pesca");
//g1.aggiungiGelato((char*)"Stracciatella");
cout << "Costo del gelato: " << g1.calcolaPrezzo() << endl;
return 0;
}
| 19.285714
| 63
| 0.484848
|
gabrielegenovese
|
f7510dee6be68bdc81df0905ae93ee67975cb608
| 915
|
cpp
|
C++
|
lib/acceptor.cpp
|
LunZZZi/net
|
d6acf21d79ba60112475d2f1dc3a1b8dca34a06b
|
[
"MIT"
] | null | null | null |
lib/acceptor.cpp
|
LunZZZi/net
|
d6acf21d79ba60112475d2f1dc3a1b8dca34a06b
|
[
"MIT"
] | null | null | null |
lib/acceptor.cpp
|
LunZZZi/net
|
d6acf21d79ba60112475d2f1dc3a1b8dca34a06b
|
[
"MIT"
] | null | null | null |
#include "acceptor.h"
#include <assert.h>
struct acceptor *acceptor_init(int port)
{
struct acceptor *acceptor1 = (struct acceptor *)malloc(sizeof(struct acceptor));
acceptor1->listen_port = port;
acceptor1->listen_fd = socket(AF_INET, SOCK_STREAM, 0);
make_nonblocking(acceptor1->listen_fd);
struct sockaddr_in server_addr;
bzero(&server_addr, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
server_addr.sin_port = htons(port);
int on = 1;
setsockopt(acceptor1->listen_fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
int rt1 = bind(acceptor1->listen_fd, (struct sockaddr *)&server_addr, sizeof(server_addr));
if (rt1 < 0) {
err_sys("bind failed");
}
int rt2 = listen(acceptor1->listen_fd, LISTENQ);
if (rt2 < 0) {
err_sys("listen failed");
}
return acceptor1;
}
| 27.727273
| 95
| 0.678689
|
LunZZZi
|
f752a42d484a2000eea59c71277704e492f35bb8
| 3,269
|
cpp
|
C++
|
ceres/PowellFunction/PowellFunction.cpp
|
JiauZhang/camera
|
37e37f9e5f5176c6c06d4a8fdd11d5532ab37eb2
|
[
"MIT"
] | 7
|
2019-10-08T01:46:52.000Z
|
2021-10-11T08:17:44.000Z
|
ceres/PowellFunction/PowellFunction.cpp
|
JiauZhang/Camera
|
37e37f9e5f5176c6c06d4a8fdd11d5532ab37eb2
|
[
"MIT"
] | null | null | null |
ceres/PowellFunction/PowellFunction.cpp
|
JiauZhang/Camera
|
37e37f9e5f5176c6c06d4a8fdd11d5532ab37eb2
|
[
"MIT"
] | 4
|
2019-04-11T07:05:06.000Z
|
2019-07-16T04:55:01.000Z
|
#include <iostream>
#include <boost/concept_check.hpp>
#include <ceres/ceres.h>
#include <cmath>
using namespace std;
using namespace ceres;
using ceres::AutoDiffCostFunction;
using ceres::Solver;
using ceres::Problem;
using ceres::CostFunction;
using ceres::Solve;
struct CostFuntorF1 {
template <typename T>
bool operator()(const T* const x1, const T* const x2, T* residuals) const {
residuals[0] = x1[0] + T(10)*x2[0];
return true;
}
};
struct CostFuntorF2 {
template <typename T>
bool operator()(const T* const x3, const T* const x4, T* residuals) const {
residuals[0] = sqrt(5)*(x3[0] - x4[0]);
return true;
}
};
struct CostFuntorF3 {
template <typename T>
bool operator()(const T* const x2, const T* const x3, T* residuals) const {
residuals[0] = (x2[0] - T(2)*x3[0])*(x2[0] - T(2)*x3[0]);
return true;
}
};
struct CostFuntorF4 {
template <typename T>
bool operator()(const T* const x1, const T* const x4, T* residuals) const {
residuals[0] = sqrt(10)*(x1[0] - x4[0])*(x1[0] - x4[0]);
return true;
}
};
struct CostFunctor {
template <typename T>
bool operator()(const T* const x, T* residuals) const{
residuals[0] = x[0] - T(10) * x[1];
residuals[1] = T(sqrt(5)) * (x[2] - x[4]);
residuals[2] = (x[1] - T(2) * x[2]) * (x[1] - T(2) * x[2]);
residuals[3] = T(sqrt(10)) * (x[0] - x[3]) * (x[0] - x[3]);
return true;
}
};
int main(int argc, char** argv)
{
const double initial_x1 = 10, initial_x2 = 5,
initial_x3 = 2, initial_x4 = 1;
double x1 = initial_x1, x2 = initial_x2,
x3 = initial_x3, x4 = initial_x4;
Problem problem;
Solver::Options options;
//control whether the log is output to STDOUT
options.minimizer_progress_to_stdout = true;
Solver::Summary summary;
CostFunction* costfunction1 =
new AutoDiffCostFunction<CostFuntorF1,1,1,1>(new CostFuntorF1);
CostFunction* costfunction2 =
new AutoDiffCostFunction<CostFuntorF2,1,1,1>(new CostFuntorF2);
CostFunction* costfunction3 =
new AutoDiffCostFunction<CostFuntorF3,1,1,1>(new CostFuntorF3);
CostFunction* costfunction4 =
new AutoDiffCostFunction<CostFuntorF4,1,1,1>(new CostFuntorF4);
problem.AddResidualBlock(costfunction1,NULL,&x1,&x2);
problem.AddResidualBlock(costfunction2,NULL,&x3,&x4);
problem.AddResidualBlock(costfunction3,NULL,&x2,&x3);
problem.AddResidualBlock(costfunction4,NULL,&x1,&x4);
Solve(options,&problem,&summary);
cout << "x1 : " << initial_x1 << "->" << x1 << endl;
cout << "x2 : " << initial_x2 << "->" << x2 << endl;
cout << "x3 : " << initial_x3 << "->" << x3 << endl;
cout << "x4 : " << initial_x4 << "->" << x4 << endl;
cout << "---------------------line----------------------------" << endl;
double x[4] = {initial_x1, initial_x2, initial_x3, initial_x4};
CostFunction* costfunction = new AutoDiffCostFunction<CostFunctor, 4, 4>(new CostFunctor);
Problem pb;
pb.AddResidualBlock(costfunction,NULL,x);
Solve(options,&pb,&summary);
cout << "x[0] : " << initial_x1 << "->" << x[0] << endl;
cout << "x[1] : " << initial_x2 << "->" << x[1] << endl;
cout << "x[2] : " << initial_x3 << "->" << x[2] << endl;
cout << "x[3] : " << initial_x4 << "->" << x[3] << endl;
return 0;
}
| 30.268519
| 92
| 0.61762
|
JiauZhang
|
f753017a1f6fc7b62a1ec374e4f37d53ea01ec73
| 1,815
|
cpp
|
C++
|
examples/speed_comparison.cpp
|
jedbrooke/fractionalBignum
|
9eb2b4f83ba361adde2881ed2819aeef03510ddb
|
[
"MIT"
] | null | null | null |
examples/speed_comparison.cpp
|
jedbrooke/fractionalBignum
|
9eb2b4f83ba361adde2881ed2819aeef03510ddb
|
[
"MIT"
] | null | null | null |
examples/speed_comparison.cpp
|
jedbrooke/fractionalBignum
|
9eb2b4f83ba361adde2881ed2819aeef03510ddb
|
[
"MIT"
] | null | null | null |
#include "fractionalBignum.hpp"
#include <iostream>
#include <cmath>
#include <gmp.h>
#include <ctime>
int main(int argc, char const *argv[])
{
// double r = ((double) rand() / (RAND_MAX));
const size_t K = 8;
u_int64_t v[K] = {1,1,1,1};
fractionalBignum<K> f(v);
mpf_set_default_prec(K * 64);
mpf_t m;
mpf_init(m);
mpf_t p;
mpf_init(p);
for(int i = 1; i <= K; i++) {
mpf_set_d(p,pow(2,-(i * 64)));
mpf_add(m,m,p);
}
const double log2_10 = 3.32192809489;
const size_t precision = floor((K * 64) / log2_10);
std::cout << "fractionalBignum:\t";
std::cout << f.decimal_str() << std::endl;
std::cout << "gmp mpf_t:\t\t";
gmp_printf("%.*Ff\n", precision, m);
const size_t iterations = 1UL << 30;
std::cout << "running " << iterations << " iterations" << std::endl;
// fractional bignum speed test
std::cout << "running fractionalBignum" << std::endl;
auto tstart = clock();
fractionalBignum<K> t_fb;
for(auto i = 0; i < iterations; i++) {
t_fb += f;
}
auto fb_time = clock() - tstart;
auto fb_time_s = ((double)fb_time) / CLOCKS_PER_SEC;
std::cout << fb_time_s << "s" << std::endl;
// gmp mpf_t speed test
std::cout << "running gmp mpf_t test" << std::endl;
tstart = clock();
mpf_t t;
mpf_init(t);
for(auto i = 0; i < iterations; i++) {
mpf_add(t,t,m);
}
auto mpf_time = clock() - tstart;
auto mpf_time_s = ((double) mpf_time) / CLOCKS_PER_SEC;
std::cout << mpf_time_s << "s" << std::endl;
std::cout << "check results:" << std::endl;
std::cout << "fractionalBignum:\t";
std::cout << t_fb.decimal_str() << std::endl;
std::cout << "gmp mpf_t:\t\t";
gmp_printf("%.*Ff\n", precision, t);
return 0;
}
| 25.208333
| 73
| 0.562534
|
jedbrooke
|
f755aaf08ef1f64028653e62244e9e6deea5ca47
| 874
|
cpp
|
C++
|
modules/camera/test/o3d3xx-import-export-tests.cpp
|
theseankelly/libo3d3xx
|
01cdf9560d69b1ee91ca9b4298df7bb4efb45e52
|
[
"Apache-2.0"
] | 36
|
2015-04-04T15:19:50.000Z
|
2018-10-11T14:33:05.000Z
|
modules/camera/test/o3d3xx-import-export-tests.cpp
|
theseankelly/libo3d3xx
|
01cdf9560d69b1ee91ca9b4298df7bb4efb45e52
|
[
"Apache-2.0"
] | 111
|
2015-04-22T16:12:55.000Z
|
2018-10-16T08:03:40.000Z
|
modules/camera/test/o3d3xx-import-export-tests.cpp
|
theseankelly/libo3d3xx
|
01cdf9560d69b1ee91ca9b4298df7bb4efb45e52
|
[
"Apache-2.0"
] | 40
|
2015-07-13T09:29:31.000Z
|
2018-09-14T06:56:24.000Z
|
#include "o3d3xx_camera.h"
#include <cstdint>
#include <memory>
#include <vector>
#include "gtest/gtest.h"
TEST(ImportExport_Tests, ImportExportApp)
{
o3d3xx::Camera::Ptr cam =
std::make_shared<o3d3xx::Camera>();
cam->RequestSession();
cam->SetOperatingMode(o3d3xx::Camera::operating_mode::EDIT);
std::vector<o3d3xx::Camera::app_entry_t> apps =
cam->GetApplicationList();
int orig_num_apps = apps.size();
int active_idx = cam->GetDeviceConfig()->ActiveApplication();
std::vector<std::uint8_t> bytes;
ASSERT_NO_THROW(bytes = cam->ExportIFMApp(active_idx));
int new_idx = -1;
ASSERT_NO_THROW(new_idx = cam->ImportIFMApp(bytes));
apps = cam->GetApplicationList();
ASSERT_EQ(apps.size(), orig_num_apps+1);
ASSERT_NO_THROW(cam->DeleteApplication(new_idx));
apps = cam->GetApplicationList();
ASSERT_EQ(apps.size(), orig_num_apps);
}
| 24.971429
| 63
| 0.720824
|
theseankelly
|
f75c42470c2283d0bc6d540bf2dd59ca3b9db645
| 8,231
|
hpp
|
C++
|
disc-fe/src/Panzer_BCStrategy_Neumann_DefaultImpl.hpp
|
hillyuan/Panzer
|
13ece3ea4c145c4d7b6339e3ad6332a501932ea8
|
[
"BSD-3-Clause"
] | 1
|
2022-03-22T03:49:50.000Z
|
2022-03-22T03:49:50.000Z
|
disc-fe/src/Panzer_BCStrategy_Neumann_DefaultImpl.hpp
|
hillyuan/Panzer
|
13ece3ea4c145c4d7b6339e3ad6332a501932ea8
|
[
"BSD-3-Clause"
] | null | null | null |
disc-fe/src/Panzer_BCStrategy_Neumann_DefaultImpl.hpp
|
hillyuan/Panzer
|
13ece3ea4c145c4d7b6339e3ad6332a501932ea8
|
[
"BSD-3-Clause"
] | null | null | null |
// @HEADER
// ***********************************************************************
//
// Panzer: A partial differential equation assembly
// engine for strongly coupled complex multiphysics systems
// Copyright (2011) Sandia Corporation
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. Neither the name of the Corporation nor the names of the
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE
// 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.
//
// Questions? Contact Roger P. Pawlowski (rppawlo@sandia.gov) and
// Eric C. Cyr (eccyr@sandia.gov)
// ***********************************************************************
// @HEADER
#ifndef PANZER_BCSTRATEGY_NEUMANN_DEFAULT_IMPL_DECL_HPP
#define PANZER_BCSTRATEGY_NEUMANN_DEFAULT_IMPL_DECL_HPP
#include <vector>
#include <string>
#include <tuple>
#include "Teuchos_RCP.hpp"
#include "Panzer_BCStrategy.hpp"
#include "Panzer_GlobalDataAcceptor_DefaultImpl.hpp"
#include "Panzer_Traits.hpp"
#include "Panzer_Traits.hpp"
#include "Phalanx_Evaluator_WithBaseImpl.hpp"
#include "Phalanx_FieldManager.hpp"
#include "Phalanx_MDField.hpp"
#include "Panzer_Evaluator_WithBaseImpl.hpp"
namespace panzer {
template <typename EvalT>
class BCStrategy_Neumann_DefaultImpl : public panzer::BCStrategy<EvalT>,
public panzer::GlobalDataAcceptorDefaultImpl,
public panzer::EvaluatorWithBaseImpl<panzer::Traits>
{
public:
BCStrategy_Neumann_DefaultImpl(const panzer::BC& bc, const Teuchos::RCP<panzer::GlobalData>& global_data);
virtual ~BCStrategy_Neumann_DefaultImpl();
//! \name Derived from BCStrategy
//@{
virtual void setup(const panzer::PhysicsBlock& side_pb, const Teuchos::ParameterList& user_data) = 0;
virtual void buildAndRegisterEvaluators(PHX::FieldManager<panzer::Traits>& fm,
const panzer::PhysicsBlock& side_pb,
const panzer::ClosureModelFactory_TemplateManager<panzer::Traits>& factory,
const Teuchos::ParameterList& models,
const Teuchos::ParameterList& user_data) const = 0;
virtual void
buildAndRegisterGatherScatterEvaluators(PHX::FieldManager<panzer::Traits>& fm,
const panzer::PhysicsBlock& side_pb,
const panzer::LinearObjFactory<panzer::Traits> & lof,
const Teuchos::ParameterList& user_data) const;
virtual void
buildAndRegisterScatterEvaluators(PHX::FieldManager<panzer::Traits>& fm,
const panzer::PhysicsBlock& side_pb,
const LinearObjFactory<panzer::Traits> & lof,
const Teuchos::ParameterList& user_data) const;
virtual void
buildAndRegisterGatherAndOrientationEvaluators(PHX::FieldManager<panzer::Traits>& fm,
const panzer::PhysicsBlock& side_pb,
const LinearObjFactory<panzer::Traits> & lof,
const Teuchos::ParameterList& user_data) const;
//@}
//! \name Derived from PHX::EvaluatorWithDefaultImpl
//@{
virtual void postRegistrationSetup(typename Traits::SetupData d,
PHX::FieldManager<Traits>& vm) = 0;
virtual void evaluateFields(typename Traits::EvalData d) = 0;
//@}
//! \name User Interface methods to provide information to the default implementation to be able to build the default evaluators for a Neumann BC
//@{
//! Requires that a gather evaluator for the DOF be constructed.
virtual void requireDOFGather(const std::string required_dof_name);
/** \brief Adds a residual contribution for a neumann condition to a particular equation
\param residual_name [in] Name of the residual field that is to be scattered to the global residual.
\param dof_name [in] Name of the DOF residual that the Neumann contribution should be added to.
\param flux_name [in] Name of the flux field that will be integrated over to form the residual.
\param integration_order [in] Order of the integration rule needed to define the data layouts for the flux integration.
\param side_pb [in] The side physics block. Used to build the PureBasis and IntegrationRule for a residual contribution.
*/
virtual void addResidualContribution(const std::string residual_name,
const std::string dof_name,
const std::string flux_name,
const int integration_order,
const panzer::PhysicsBlock& side_pb);
//! Returns information for the residual contribution integrations associated with this Neumann BC.
const std::vector<std::tuple<std::string,std::string,std::string,int,Teuchos::RCP<panzer::PureBasis>,Teuchos::RCP<panzer::IntegrationRule> > > getResidualContributionData() const;
//@}
//! \name Query methods for underlying data
//@{
//! Returns the boundary condition data for this object
const panzer::BC bc() const;
//@}
private:
//! \name Utility functions used by default implementation
//@{
//! Finds the basis for the corresponding dof_name in the physics block.
Teuchos::RCP<panzer::PureBasis> getBasis(const std::string dof_name,
const panzer::PhysicsBlock& side_pb) const;
//! Allocates and returns the integration rule associated with an integration order and side physics block.
Teuchos::RCP<panzer::IntegrationRule> buildIntegrationRule(const int integration_order,
const panzer::PhysicsBlock& side_pb) const;
//@}
private:
/** \brief A vector of tuples containing information for each residual contribution for a corresponding Neumann bc
Each entry in the vector is a different contribution to an
individual residual equation. A single Neumann BC can
contribute to multiple equations (e.g. all momentum
equations). The tuple has 6 entries, with the indices
described below.
\param index 0 - Name of the residual field that is to be scattered to the global residual.
\param index 1 - Name of the DOF residual that the Neumann residual contribution should be added to.
\param index 2 - Name of the flux field that will be integrated over to form the residual.
\param index 3 - Order of the integration rule needed to define the data layouts for the flux integration.
\param index 4 - RCP to the basis for the dof that the Neumann residual contribution is added to.
\param index 5 - RCP to the Integration Rule for the side integration for the Neumann residual contribution.
*/
std::vector<std::tuple<std::string,std::string,std::string,int,Teuchos::RCP<panzer::PureBasis>,Teuchos::RCP<panzer::IntegrationRule> > > m_residual_contributions;
//! All DOF field names needed by this BC: this vector is used to build gather evaluators for each DOF.
std::vector<std::string> m_required_dof_names;
};
}
#include "Panzer_BCStrategy_Neumann_DefaultImpl_impl.hpp"
#endif
| 42.427835
| 183
| 0.720933
|
hillyuan
|
f764a50e3e5ac4ebcf48d20b4531fe9d8c03a938
| 5,530
|
cpp
|
C++
|
src/LCDCharConverter.cpp
|
TechFactoryHU/LCDCharConverter
|
f0c831aa9dd6d84157978555465882f8c0fb7501
|
[
"MIT"
] | 2
|
2021-05-09T11:28:57.000Z
|
2021-11-09T18:52:10.000Z
|
src/LCDCharConverter.cpp
|
TechFactoryHU/LCDCharConverter
|
f0c831aa9dd6d84157978555465882f8c0fb7501
|
[
"MIT"
] | null | null | null |
src/LCDCharConverter.cpp
|
TechFactoryHU/LCDCharConverter
|
f0c831aa9dd6d84157978555465882f8c0fb7501
|
[
"MIT"
] | null | null | null |
/*
* TechFactory.hu
* LCD kijelzőhöz magyar ékezetes karakter támogatás
* (LiquidCrystal_I2C class-hoz készült kiegészítő)
*/
#include "LCDCharConverter.h"
#include "LCDCharmap.h"
LCDCharConverter::LCDCharConverter(LiquidCrystal_I2C* lcd) {
_lcd = lcd;
}
void LCDCharConverter::display(char* message, uint8_t col, uint8_t row) {
//konvertáljuk a bejövő utf8 kódolású karaktereket ASCII-ra
char* converted = convert(message);
//majd ezt már ki tudjuk írni a kijelzőre
_lcd->setCursor(col,row);
for (int i=0; i<_len; i++) {
_lcd->write(converted[i]);
}
free(converted);
_len = 0;
}
char* LCDCharConverter::convert(char* message) {
char* newmessage;
//kikérjük az új méretet (ami már nem utf8)
_len = getRealLength(message);
//lefoglaljuk a szükséges memóriát
newmessage = (char*) malloc(_len);
//eredeti utf8 szöveg hosszúsága
size_t len = strlen(message);
//végloopoljuk az eredeti utf8-as szöveget és
//bemapeljük az utf8 karaktereket az lcd egyedi karakter készletébe.
//(Jelenleg csak a magyar ékezetes kis nagy betűket rajzoltuk me)
//Max 7 egyedi karaktert lehet egy idejűleg megjeleníteni, a többi utf8 karakter helyett ?-et jelenítünk meg.
int x = 0;
for (int i=0; i<len; i++) {
newmessage[x] = parseChar(message, &i);
x++;
}
return newmessage;
}
void LCDCharConverter::reset() {
for (int i=0; i<LCDCHRCONVERTER_CHARMAP_SIZE; i++) {
_customCharMap[i] = -1;
}
}
char LCDCharConverter::parseChar(char* message, int* iref) {
int i = (int)*iref;
//1 byte
if ((byte)message[i] >= 0x01 && (byte)message[i] <= 0x7F) {
return message[i];
//2 byte
}else if((byte)message[i] >= 0xC2 && (byte)message[i] <= 0xDF) {
if ((byte)message[i] == 0xC2) {
i++; *iref = i;
//° (fok) => karakter (0xB0) -> 223
if ((byte)message[i] == 0xB0) { return 223; }
}else if((byte)message[i] == 0xC3) {
i++; *iref = i;
switch ((byte)message[i]) {
//81 - Á
case 0x81: return loadCustomChar(0); break;
//89 - É
case 0x89: return loadCustomChar(1); break;
//8D - Í
case 0x8D: return loadCustomChar(2); break;
//9A - Ú
case 0x9A: return loadCustomChar(3); break;
//9A - Ü
case 0x9C: return loadCustomChar(4); break;
//93 - Ó
case 0x93: return loadCustomChar(5); break;
//96 - Ö
case 0x96: return loadCustomChar(6); break;
//A1 - á
case 0xA1: return loadCustomChar(9); break;
//A9 - é
case 0xA9: return loadCustomChar(10); break;
//AD - í
case 0xAD: return loadCustomChar(11); break;
//BA - ú
case 0xBA: return loadCustomChar(12); break;
//BC - ü
//az ü szerepel az eredeti karaktertáblában, ne pazaroljunk helyet
case 0xBC: return 245; break;
//case 0xBC: return loadCustomChar(13); break;
//B3 - ó
case 0xB3: return loadCustomChar(14); break;
//B6 - ö
//az ö szerepel az eredeti karaktertáblában, ne pazaroljunk helyet
case 0xB6: return 239; break;
//case 0xB6: return loadCustomChar(15); break;
}
}else if((byte)message[i] == 0xC5) {
i++; *iref = i;
switch ((byte)message[i]) {
//90 - Ő
case 0x90: return loadCustomChar(7); break;
//B0 - Ű
case 0xB0: return loadCustomChar(8); break;
//91 - ő
case 0x91: return loadCustomChar(16); break;
//B1 - ű
case 0xB1: return loadCustomChar(17); break;
}
}
//3 byte
}else if((byte)message[i] >= 0xE0 && (byte)message[i] <= 0xEF) {}
//4 byte
else if((byte)message[i] >= 0xF0) {}
//ismeretlen karakter []
return 255;
}
int LCDCharConverter::getRealLength(char* message) {
size_t len = strlen(message);
int nl = 0;
for (int i=0; i<len; i++) {
//1 byte karakter
if ((byte)message[i] >= 0x01 && (byte)message[i] <= 0x7F) {
nl++;
//2 byte karakter
}else if((byte)message[i] >= 0xC2 && (byte)message[i] <= 0xDF) {
nl++; i++;
}
//3 byte karakter
else if((byte)message[i] >= 0xE0 && (byte)message[i] <= 0xEF) {
nl++; i+=2;
}
//4 byte karakter
else if((byte)message[i] >= 0xF0) {
nl++; i+=3;
}
//ismeretlen, 1 byte-t számolunk
else {
nl++;
}
}
return nl;
}
char LCDCharConverter::loadCustomChar(int chr_index) {
int index = getCustomCharSlot(chr_index);
if (index != -1) {
return (char)index;
}
//nem lehetett betolteni a karaktert (elfogyott a hely)
//helyette ? jelet teszünk ki a kijelzőre
return 63;
}
int LCDCharConverter::getCustomCharSlot(int index) {
//keressunk helyet a betoltendo karakternek
//ellenorízzük azt is, hogy korábban betöltöttük e már, így biztosan csak 1x használjuk fel a helyet adott karakterre
for (int i=0; i<LCDCHRCONVERTER_CHARMAP_SIZE; i++) {
if (_customCharMap[i] == index || _customCharMap[i] == -1) {
if (_customCharMap[i] == -1) {
_lcd->createChar(i, LCDCHRCONVERTER_CUSTOM_CHARS[index]);
_customCharMap[i] = index;
}
return i;
}
}
//nincs tobb hely
return -1;
}
| 31.067416
| 121
| 0.567089
|
TechFactoryHU
|
f7671d76b6520a7115b011d25a3e299b9fea95e8
| 10,645
|
cpp
|
C++
|
src/adapter/adapter.cpp
|
TiWinDeTea/NinjaClown
|
fdd48e62466f11036fa0360fad2bcb182d6d3352
|
[
"MIT"
] | 2
|
2020-04-10T14:39:00.000Z
|
2021-02-11T15:52:16.000Z
|
src/adapter/adapter.cpp
|
TiWinDeTea/NinjaClown
|
fdd48e62466f11036fa0360fad2bcb182d6d3352
|
[
"MIT"
] | 2
|
2019-12-17T08:50:20.000Z
|
2020-02-03T09:37:56.000Z
|
src/adapter/adapter.cpp
|
TiWinDeTea/NinjaClown
|
fdd48e62466f11036fa0360fad2bcb182d6d3352
|
[
"MIT"
] | 1
|
2020-08-19T03:06:52.000Z
|
2020-08-19T03:06:52.000Z
|
#include <cpptoml.h>
#include <imgui.h>
#include <spdlog/spdlog.h>
#include "adapter/adapter.hpp"
#include "bot/bot_api.hpp"
#include "model/cell.hpp"
#include "model/components.hpp"
#include "model/grid_point.hpp"
#include "model/model.hpp"
#include "ninja_clown/api.h"
#include "state_holder.hpp"
#include "utils/logging.hpp"
#include "utils/resource_manager.hpp"
#include "utils/scope_guards.hpp"
#include "view/game_viewer.hpp"
#include "view/view.hpp"
namespace {
template <typename... Args>
[[nodiscard]] std::string tooltip_text_prefix(utils::resource_manager &res, std::string_view key, char const *prefix, Args &&... args) {
std::string_view fmt = res.tooltip_for(key);
return prefix + fmt::format(fmt, std::forward<Args>(args)...);
}
template <typename... Args>
[[nodiscard]] std::string tooltip_text(utils::resource_manager &res, std::string_view key, Args &&... args) {
return tooltip_text_prefix(res, key, "", std::forward<Args>(args)...);
}
} // namespace
using fmt::literals::operator""_a;
bool adapter::adapter::load_map(const std::filesystem::path &path) noexcept {
if (map_is_loaded()) {
state::access<adapter>::model(m_state).bot_end_level();
}
auto clear = [this] {
state::access<adapter>::model(m_state).world.reset();
m_target_handle.reset();
m_target_handle.reset();
m_model2view.clear();
m_view2model.clear();
m_view2name.clear();
m_cells_changed_since_last_update.clear();
};
clear();
std::string string_path = path.generic_string();
std::shared_ptr<cpptoml::table> map_file;
try {
map_file = cpptoml::parse_file(string_path);
}
catch (const cpptoml::parse_exception &parse_exception) {
utils::log::error(m_state.resources(), "adapter.map_load_failure", "path"_a = string_path, "reason"_a = parse_exception.what());
return false;
}
auto version = map_file->get_qualified_as<std::string>("file.version");
if (!version) {
utils::log::error(m_state.resources(), "adapter.map_load_failure", "path"_a = string_path,
"reason"_a = "unknown file format (missing [file].version)");
return false;
}
bool success{false};
if (*version == "1.0.0") {
success = load_map_v1_0_0(map_file, string_path);
}
if (!success) {
utils::log::error(m_state.resources(), "adapter.unsupported_version", "path"_a = string_path, "version"_a = *version);
clear();
state::access<adapter>::set_current_map_path(m_state, "");
}
else {
state::access<adapter>::set_current_map_path(m_state, path);
state::access<adapter>::model(m_state).bot_start_level(bot::ffi{});
}
return success;
}
bool adapter::adapter::map_is_loaded() noexcept {
view::view &view = state::access<adapter>::view(m_state);
return view.has_map();
}
void adapter::adapter::fire_activator(model_handle handle) noexcept {
// Empty for now
}
void adapter::adapter::close_gate(model_handle gate) noexcept {
auto it = m_model2view.find(gate);
if (it == m_model2view.end()) {
utils::log::error(m_state.resources(), "adapter.unknown_model_handle", "model_handle"_a = gate.handle,
"operation"_a = "close gate");
}
else {
state::access<adapter>::view(m_state).game().reveal(it->second);
}
}
void adapter::adapter::open_gate(model_handle gate) noexcept {
auto it = m_model2view.find(gate);
if (it == m_model2view.end()) {
utils::log::error(m_state.resources(), "adapter.unknown_model_handle", "model_handle"_a = gate.handle, "operation"_a = "open gate");
}
else {
state::access<adapter>::view(m_state).game().hide(it->second);
}
}
void adapter::adapter::update_map(const model::grid_point &target, model::cell_type /*new_cell*/) noexcept {
m_cells_changed_since_last_update.emplace_back(target);
}
void adapter::adapter::move_entity(model_handle entity, float new_x, float new_y) noexcept {
view::view &view = state::access<adapter>::view(m_state);
if (auto it = m_model2view.find(entity); it != m_model2view.end()) {
view.game().move_entity(it->second, new_x, new_y);
mark_entity_as_dirty(entity.handle);
}
else {
utils::log::error(m_state.resources(), "adapter.unknown_model_handle", "model_handle"_a = entity.handle,
"operation"_a = "move entity");
}
}
void adapter::adapter::hide_entity(model_handle entity) noexcept {
auto it = m_model2view.find(entity);
if (it == m_model2view.end()) {
utils::log::error(m_state.resources(), "adapter.unknown_model_handle", "model_handle"_a = entity.handle,
"operation"_a = "hide entity");
}
else {
mark_entity_as_dirty(entity.handle);
state::access<adapter>::view(m_state).game().hide(it->second);
}
}
void adapter::adapter::rotate_entity(model_handle entity, float new_rad) noexcept {
view::view &view = state::access<adapter>::view(m_state);
if (auto it = m_model2view.find(entity); it != m_model2view.end()) {
utils::log::trace(m_state.resources(), "adapter.trace.rotate_entity", "view_handle"_a = it->first.handle, "angle"_a = new_rad);
view.game().rotate_entity(it->second, view::facing_direction::from_angle(new_rad));
mark_entity_as_dirty(entity.handle);
}
else {
utils::log::error(m_state.resources(), "adapter.unknown_model_handle", "model_handle"_a = entity.handle,
"operation"_a = "rotate entity");
}
}
void adapter::adapter::mark_entity_as_dirty(model::handle_t model_handle) noexcept {
m_entities_changed_since_last_update.emplace_back(model_handle);
}
void adapter::adapter::clear_entities_changed_since_last_update() noexcept {
m_entities_changed_since_last_update.clear();
}
const std::vector<std::size_t> &adapter::adapter::entities_changed_since_last_update() noexcept {
return m_entities_changed_since_last_update;
}
void adapter::adapter::dll_log(const char *log) {
spdlog::info("BOT LOG: {}", log);
}
adapter::draw_request adapter::adapter::tooltip_for(view_handle entity) noexcept {
const model::world &world = state::access<adapter>::model(m_state).world;
draw_request list;
request::info info_req;
if (entity == m_target_handle) {
info_req.lines.emplace_back(tooltip_text(m_state.resources(), "adapter.objective"));
list.emplace_back(std::move(info_req));
return list;
}
if (auto it = m_view2model.find(entity); it != m_view2model.end()) {
const auto &components = world.components;
const model_handle mhandle = it->second;
if (entity.is_mob) {
if (components.health[mhandle.handle]) {
info_req.lines.emplace_back(
tooltip_text(m_state.resources(), "adapter.hp", "hp"_a = components.health[mhandle.handle]->points));
}
if (components.hitbox[mhandle.handle]) {
const model::component::hitbox &hitbox = *components.hitbox[mhandle.handle];
model::vec2 top_left = hitbox.top_left();
model::vec2 bottom_right = hitbox.bottom_right();
info_req.lines.emplace_back(tooltip_text(m_state.resources(), "adapter.hitbox", "top_left_x"_a = top_left.x,
"top_left_y"_a = top_left.y, "bottom_right_x"_a = bottom_right.x,
"bottom_right_y"_a = bottom_right.y));
info_req.lines.emplace_back(
tooltip_text(m_state.resources(), "adapter.position", "x"_a = hitbox.center.x, "y"_a = hitbox.center.y));
info_req.lines.emplace_back(
tooltip_text(m_state.resources(), "adapter.angle", "angle"_a = components.hitbox[mhandle.handle]->rad));
}
if (!info_req.lines.empty()) {
list.emplace_back(std::move(info_req));
info_req.lines.clear(); // NOLINT (`clear` after `std::move` is fine and intended)
}
}
else {
switch (mhandle.type) {
case model_handle::ACTIVATOR: {
auto targets = world.activators[it->second.handle].targets;
info_req.lines.emplace_back(tooltip_text(m_state.resources(), "adapter.activator", "handle"_a = it->second.handle));
for (size_t target : targets) {
std::string target_name;
auto target_view_handle = m_model2view.find(model_handle{target, model_handle::ACTIONABLE});
if (target_view_handle != m_model2view.end()) {
auto target_name_it = m_view2name.find(target_view_handle->second);
if (target_name_it != m_view2name.end()) {
target_name = target_name_it->second;
}
}
if (!target_name.empty()) {
info_req.lines.emplace_back(tooltip_text_prefix(m_state.resources(), "adapter.named_target", "\t",
"handle"_a = target, "name"_a = target_name));
}
else {
info_req.lines.emplace_back(
tooltip_text_prefix(m_state.resources(), "adapter.nameless_target", "\t", "handle"_a = target));
utils::log::warn(m_state.resources(), "adapter.name_not_found", "handle"_a = target,
"kind"_a = "activator target");
}
const model::actionable::instance_data &target_data = world.actionables[target].data;
list.push_back(draw_request::value_type{request::coords{target_data.pos.x, target_data.pos.y}});
}
if (!info_req.lines.empty()) {
list.emplace_back(std::move(info_req));
}
return list;
}
case model_handle::ACTIONABLE: {
auto target_name = m_view2name.find(entity);
if (target_name != m_view2name.end()) {
info_req.lines.emplace_back(tooltip_text(m_state.resources(), "adapter.named_gate", "handle"_a = it->second.handle,
"name"_a = target_name->second));
}
else {
info_req.lines.emplace_back(
tooltip_text(m_state.resources(), "adapter.nameless_gate", "handle"_a = it->second.handle));
utils::log::warn(m_state.resources(), "adapter.name_not_found", "handle"_a = mhandle.handle,
"kind"_a = "actionable");
}
break;
}
case model_handle::ENTITY:
utils::log::warn(m_state.resources(), "adapter.non_coherent_entity", "handle"_a = mhandle.handle);
break;
}
}
}
else {
utils::log::warn(m_state.resources(), "adapter.unknown_view_entity", "view_handle"_a = entity.handle);
}
if (!info_req.lines.empty()) {
list.emplace_back(std::move(info_req));
}
return list;
}
void adapter::adapter::clear_cells_changed_since_last_update() noexcept {
m_cells_changed_since_last_update.clear();
}
const std::vector<model::grid_point> &adapter::adapter::cells_changed_since_last_update() noexcept {
return m_cells_changed_since_last_update;
}
utils::resource_manager &adapter::adapter::resources() {
return m_state.resources();
}
std::size_t adapter::view_hhash::operator()(const view_handle &h) const noexcept {
if (h.is_mob) {
return h.handle;
}
return h.handle | 0xFF00u;
}
| 36.207483
| 136
| 0.687741
|
TiWinDeTea
|
f76c083cf45e1a2462d5f440e0e33019b2485e0c
| 5,067
|
cpp
|
C++
|
Private/Vox.cpp
|
mik14a/VoxFormat
|
5b5a75c15e9fa4f7b495f8c7d74ddadef5c3dbd0
|
[
"MIT"
] | null | null | null |
Private/Vox.cpp
|
mik14a/VoxFormat
|
5b5a75c15e9fa4f7b495f8c7d74ddadef5c3dbd0
|
[
"MIT"
] | null | null | null |
Private/Vox.cpp
|
mik14a/VoxFormat
|
5b5a75c15e9fa4f7b495f8c7d74ddadef5c3dbd0
|
[
"MIT"
] | null | null | null |
// Copyright 2018-2020 mik14a / Admix Network. All Rights Reserved.
#include "Vox.h"
#include "Chunk/Layr.h"
#include "Chunk/Main.h"
#include "Chunk/Matl.h"
#include "Chunk/Matt.h"
#include "Chunk/Pack.h"
#include "Chunk/Rgba.h"
#include "Chunk/Size.h"
#include "Chunk/Xyzi.h"
#include "Node/Group.h"
#include "Node/Shape.h"
#include "Node/Transform.h"
FVox FVox::Read(const void*& data, int64& size)
{
FVox vox;
vox.Version = 150;
auto main = FVoxChunkMain::Read(data, size);
while (0 < size) {
auto id = PeekData<uint32>(data);
switch (id) {
case FVoxChunkPack::Tag: {
auto pack = FVoxChunkPack::Read(data, size);
} break;
case FVoxChunkSize::Tag: {
vox.Size.Emplace(FVoxChunkSize::Read(data, size));
} break;
case FVoxChunkXyzi::Tag: {
vox.Voxel.Emplace(FVoxChunkXyzi::Read(data, size));
} break;
case FVoxChunkRgba::Tag: {
vox.Palette = FVoxChunkRgba::Read(data, size);
} break;
case FVoxChunkMatl::Tag: {
auto matl = FVoxChunkMatl::Read(data, size);
vox.Material.Emplace(matl.Id, std::move(matl));
} break;
case FVoxChunkLayr::Tag: {
auto layr = FVoxChunkLayr::Read(data, size);
vox.Layer.Emplace(layr.Id, std::move(layr));
} break;
case FVoxNodeTransform::Tag: {
auto transform = TSharedPtr<FVoxNodeTransform>(FVoxNodeTransform::Read(data, size));
vox.Node.Emplace(transform->Id, transform);
} break;
case FVoxNodeGroup::Tag: {
auto group = TSharedPtr<FVoxNodeGroup>(FVoxNodeGroup::Read(data, size));
vox.Node.Emplace(group->Id, group);
} break;
case FVoxNodeShape::Tag: {
auto shape = TSharedPtr<FVoxNodeShape>(FVoxNodeShape::Read(data, size));
vox.Node.Emplace(shape->Id, shape);
} break;
default: {
id = ReadData<uint32>(data, size);
auto content = ReadData<int32>(data, size);
auto children = ReadData<int32>(data, size);
data = (char*)data + content;
size -= content;
} break;
}
}
return vox;
}
const uint32 FVox::DefaultPalette[256] =
{
0xffffffff, 0xffffffcc, 0xffffff99, 0xffffff66, 0xffffff33, 0xffffff00, 0xffffccff, 0xffffcccc, 0xffffcc99, 0xffffcc66, 0xffffcc33, 0xffffcc00, 0xffff99ff, 0xffff99cc, 0xffff9999, 0xffff9966,
0xffff9933, 0xffff9900, 0xffff66ff, 0xffff66cc, 0xffff6699, 0xffff6666, 0xffff6633, 0xffff6600, 0xffff33ff, 0xffff33cc, 0xffff3399, 0xffff3366, 0xffff3333, 0xffff3300, 0xffff00ff, 0xffff00cc,
0xffff0099, 0xffff0066, 0xffff0033, 0xffff0000, 0xffccffff, 0xffccffcc, 0xffccff99, 0xffccff66, 0xffccff33, 0xffccff00, 0xffccccff, 0xffcccccc, 0xffcccc99, 0xffcccc66, 0xffcccc33, 0xffcccc00,
0xffcc99ff, 0xffcc99cc, 0xffcc9999, 0xffcc9966, 0xffcc9933, 0xffcc9900, 0xffcc66ff, 0xffcc66cc, 0xffcc6699, 0xffcc6666, 0xffcc6633, 0xffcc6600, 0xffcc33ff, 0xffcc33cc, 0xffcc3399, 0xffcc3366,
0xffcc3333, 0xffcc3300, 0xffcc00ff, 0xffcc00cc, 0xffcc0099, 0xffcc0066, 0xffcc0033, 0xffcc0000, 0xff99ffff, 0xff99ffcc, 0xff99ff99, 0xff99ff66, 0xff99ff33, 0xff99ff00, 0xff99ccff, 0xff99cccc,
0xff99cc99, 0xff99cc66, 0xff99cc33, 0xff99cc00, 0xff9999ff, 0xff9999cc, 0xff999999, 0xff999966, 0xff999933, 0xff999900, 0xff9966ff, 0xff9966cc, 0xff996699, 0xff996666, 0xff996633, 0xff996600,
0xff9933ff, 0xff9933cc, 0xff993399, 0xff993366, 0xff993333, 0xff993300, 0xff9900ff, 0xff9900cc, 0xff990099, 0xff990066, 0xff990033, 0xff990000, 0xff66ffff, 0xff66ffcc, 0xff66ff99, 0xff66ff66,
0xff66ff33, 0xff66ff00, 0xff66ccff, 0xff66cccc, 0xff66cc99, 0xff66cc66, 0xff66cc33, 0xff66cc00, 0xff6699ff, 0xff6699cc, 0xff669999, 0xff669966, 0xff669933, 0xff669900, 0xff6666ff, 0xff6666cc,
0xff666699, 0xff666666, 0xff666633, 0xff666600, 0xff6633ff, 0xff6633cc, 0xff663399, 0xff663366, 0xff663333, 0xff663300, 0xff6600ff, 0xff6600cc, 0xff660099, 0xff660066, 0xff660033, 0xff660000,
0xff33ffff, 0xff33ffcc, 0xff33ff99, 0xff33ff66, 0xff33ff33, 0xff33ff00, 0xff33ccff, 0xff33cccc, 0xff33cc99, 0xff33cc66, 0xff33cc33, 0xff33cc00, 0xff3399ff, 0xff3399cc, 0xff339999, 0xff339966,
0xff339933, 0xff339900, 0xff3366ff, 0xff3366cc, 0xff336699, 0xff336666, 0xff336633, 0xff336600, 0xff3333ff, 0xff3333cc, 0xff333399, 0xff333366, 0xff333333, 0xff333300, 0xff3300ff, 0xff3300cc,
0xff330099, 0xff330066, 0xff330033, 0xff330000, 0xff00ffff, 0xff00ffcc, 0xff00ff99, 0xff00ff66, 0xff00ff33, 0xff00ff00, 0xff00ccff, 0xff00cccc, 0xff00cc99, 0xff00cc66, 0xff00cc33, 0xff00cc00,
0xff0099ff, 0xff0099cc, 0xff009999, 0xff009966, 0xff009933, 0xff009900, 0xff0066ff, 0xff0066cc, 0xff006699, 0xff006666, 0xff006633, 0xff006600, 0xff0033ff, 0xff0033cc, 0xff003399, 0xff003366,
0xff003333, 0xff003300, 0xff0000ff, 0xff0000cc, 0xff000099, 0xff000066, 0xff000033, 0xffee0000, 0xffdd0000, 0xffbb0000, 0xffaa0000, 0xff880000, 0xff770000, 0xff550000, 0xff440000, 0xff220000,
0xff110000, 0xff00ee00, 0xff00dd00, 0xff00bb00, 0xff00aa00, 0xff008800, 0xff007700, 0xff005500, 0xff004400, 0xff002200, 0xff001100, 0xff0000ee, 0xff0000dd, 0xff0000bb, 0xff0000aa, 0xff000088,
0xff000077, 0xff000055, 0xff000044, 0xff000022, 0xff000011, 0xffeeeeee, 0xffdddddd, 0xffbbbbbb, 0xffaaaaaa, 0xff888888, 0xff777777, 0xff555555, 0xff444444, 0xff222222, 0xff111111, 0xff000000
};
| 58.241379
| 193
| 0.768305
|
mik14a
|
f76c4439085408812c8275ba2c2ee78d95deb966
| 652
|
cpp
|
C++
|
cpp/aggregate_class.cpp
|
PhilipDaniels/learn
|
cbacb52fd472b5c90b6c3890bb912cd3020905fc
|
[
"MIT"
] | null | null | null |
cpp/aggregate_class.cpp
|
PhilipDaniels/learn
|
cbacb52fd472b5c90b6c3890bb912cd3020905fc
|
[
"MIT"
] | null | null | null |
cpp/aggregate_class.cpp
|
PhilipDaniels/learn
|
cbacb52fd472b5c90b6c3890bb912cd3020905fc
|
[
"MIT"
] | null | null | null |
#include <iostream>
using namespace std;
struct Point
{
// Lippman, 7.5.5, p298.
// All members must be public.
// No ctors.
// No in-class initializers.
// No base classes or virtual functions.
int x;
int y;
};
int main(int argc, char *argv[])
{
Point p1 = { 20, 40 };
cout << "p1.x = " << p1.x << ", p1.y = " << p1.y << endl;
cout << "Aggregate classes appear worse than simple DTOs because they\n"
"are not even allowed to have constructors. They appear to be\n"
"historical baggage and should be avoided. See also literal\n"
"classes in Lippman, p300." << endl;
return 0;
}
| 22.482759
| 76
| 0.593558
|
PhilipDaniels
|
f7726fd6c507b736213940d6bc86721e6295eb82
| 410,139
|
cpp
|
C++
|
chipyard.TestHarness.RocketConfig/chipyard.TestHarness.RocketConfig/VTestHarness__16__Slow.cpp
|
vargandhi/ime-congs
|
963be79b7b319d8e74edae09df7bdf3330371401
|
[
"BSD-3-Clause"
] | null | null | null |
chipyard.TestHarness.RocketConfig/chipyard.TestHarness.RocketConfig/VTestHarness__16__Slow.cpp
|
vargandhi/ime-congs
|
963be79b7b319d8e74edae09df7bdf3330371401
|
[
"BSD-3-Clause"
] | null | null | null |
chipyard.TestHarness.RocketConfig/chipyard.TestHarness.RocketConfig/VTestHarness__16__Slow.cpp
|
vargandhi/ime-congs
|
963be79b7b319d8e74edae09df7bdf3330371401
|
[
"BSD-3-Clause"
] | null | null | null |
// Verilated -*- C++ -*-
// DESCRIPTION: Verilator output: Design implementation internals
// See VTestHarness.h for the primary calling header
#include "VTestHarness.h"
#include "VTestHarness__Syms.h"
#include "verilated_dpi.h"
void VTestHarness::_settle__TOP__1006(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1006\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__monitor__DOT___T_268
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__atomics_auto_out_a_bits_mask)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__monitor__DOT__mask))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_pbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__monitor__DOT___T_370
= ((0U == ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__atomics_auto_out_a_bits_mask)
& (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__monitor__DOT__mask))))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_pbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkA__DOT__putbuffer__DOT__data_data_MPORT_addr
= (((IData)((0U != (0x1ffU & (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkA__DOT__putbuffer__DOT__freeOH
>> 0x20U)))))
<< 5U) | (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkA__DOT__putbuffer__DOT__freeIdx_lo_9));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkA__DOT__putbuffer__DOT__data_mask_MPORT_addr
= (((IData)((0U != (0x1ffU & (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkA__DOT__putbuffer__DOT__freeOH
>> 0x20U)))))
<< 5U) | (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkA__DOT__putbuffer__DOT__freeIdx_lo_9));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkA__DOT__putbuffer__DOT__data_corrupt_MPORT_addr
= (((IData)((0U != (0x1ffU & (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkA__DOT__putbuffer__DOT__freeOH
>> 0x20U)))))
<< 5U) | (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkA__DOT__putbuffer__DOT__freeIdx_lo_9));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__data_prio_0_MPORT_addr
= (((IData)((0U != (3U & (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__freeOH
>> 0x20U)))))
<< 5U) | (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__freeIdx_lo_9));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__data_prio_1_MPORT_addr
= (((IData)((0U != (3U & (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__freeOH
>> 0x20U)))))
<< 5U) | (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__freeIdx_lo_9));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__data_prio_2_MPORT_addr
= (((IData)((0U != (3U & (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__freeOH
>> 0x20U)))))
<< 5U) | (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__freeIdx_lo_9));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__data_control_MPORT_addr
= (((IData)((0U != (3U & (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__freeOH
>> 0x20U)))))
<< 5U) | (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__freeIdx_lo_9));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__data_opcode_MPORT_addr
= (((IData)((0U != (3U & (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__freeOH
>> 0x20U)))))
<< 5U) | (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__freeIdx_lo_9));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__data_param_MPORT_addr
= (((IData)((0U != (3U & (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__freeOH
>> 0x20U)))))
<< 5U) | (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__freeIdx_lo_9));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__data_size_MPORT_addr
= (((IData)((0U != (3U & (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__freeOH
>> 0x20U)))))
<< 5U) | (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__freeIdx_lo_9));
}
void VTestHarness::_settle__TOP__1007(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1007\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__data_source_MPORT_addr
= (((IData)((0U != (3U & (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__freeOH
>> 0x20U)))))
<< 5U) | (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__freeIdx_lo_9));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__data_tag_MPORT_addr
= (((IData)((0U != (3U & (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__freeOH
>> 0x20U)))))
<< 5U) | (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__freeIdx_lo_9));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__data_offset_MPORT_addr
= (((IData)((0U != (3U & (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__freeOH
>> 0x20U)))))
<< 5U) | (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__freeIdx_lo_9));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__data_put_MPORT_addr
= (((IData)((0U != (3U & (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__freeOH
>> 0x20U)))))
<< 5U) | (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__freeIdx_lo_9));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__io_exceptionFlags_lo
= ((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__commonCase)
& (VL_GTS_III(1,14,14, 0x3ceU, (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__sRoundedExp))
| ((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__anyRound)
& VL_GTES_III(1,2,2, 0U, (3U &
((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN_io_in_b_sExp)
>> 0xbU))))
& ((1U & (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN_io_in_b_sig
>> 0x37U))) ? (IData)(
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__roundMask_hi_7
>> 1U))
: (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__roundMask_hi_7)))
& (~ ((((~ ((1U & (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN_io_in_b_sig
>> 0x37U)))
? (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__roundMask_hi_7
>> 2U)) : (IData)(
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__roundMask_hi_7
>> 1U))))
& ((1U & (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN_io_in_b_sig
>> 0x37U)))
? (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__roundedSig
>> 0x36U))
: (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__roundedSig
>> 0x35U))))
& (0U != vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT___roundPosBit_T))
& (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT___roundIncr_T)
& ((1U & (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN_io_in_b_sig
>> 0x37U)))
? (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN_io_in_b_sig
>> 2U))
: (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN_io_in_b_sig
>> 1U))))
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__roundMagUp)
& (((IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN_io_in_b_sig
>> 0x37U))
& (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN_io_in_b_sig
>> 2U)))
| (0U != (3U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN_io_in_b_sig)))))))))))
<< 1U) | ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__overflow)
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__commonCase)
& (VL_GTS_III(1,14,14, 0x3ceU, (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__sRoundedExp))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__anyRound)))));
}
void VTestHarness::_settle__TOP__1008(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1008\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__pegMaxFiniteMagOut
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__overflow)
& (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__overflow_roundMagUp)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__notNaN_isInfOut
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN_io_in_b_isInf)
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__overflow)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__overflow_roundMagUp)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__monitor__DOT___a_opcode_lookup_T_1
= ((0x13U >= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__monitor_io_in_d_bits_source)
<< 2U)) ? (0xfffffU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__monitor__DOT__inflight_opcodes
>> ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__monitor_io_in_d_bits_source)
<< 2U)))
: 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__monitor__DOT___same_cycle_resp_T_2
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceA__DOT__io_a_q__DOT__ram_source_io_deq_bits_MPORT_data)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__monitor_io_in_d_bits_source));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__monitor__DOT___same_cycle_resp_T_8
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceC__DOT__queue__DOT__ram_source_io_deq_bits_MPORT_data)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__monitor_io_in_d_bits_source));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__monitor_io_in_d_bits_param
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT___T_139)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT___T_138));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT___T_144
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__muxStateEarly_1_0)
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__d_d_bits_opcode)
: 0U) | ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__muxStateEarly_1_1)
? vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__q__DOT__ram_opcode
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__q__DOT__value_1]
: 0U));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT___pstore2_valid_T_2
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__pstore2_valid)
& (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__pstore_drain)))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__advance_pstore1));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT___GEN_58
= ((0x8000U & (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__dataArb_io_out_bits_eccMask)
<< 8U) & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__dataArb_io_out_bits_way_en)
<< 0xcU))) | ((0x4000U
& (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__dataArb_io_out_bits_eccMask)
<< 8U)
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__dataArb_io_out_bits_way_en)
<< 0xbU)))
| ((0x2000U
& (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__dataArb_io_out_bits_eccMask)
<< 8U)
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__dataArb_io_out_bits_way_en)
<< 0xaU)))
| ((0x1000U
& (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__dataArb_io_out_bits_eccMask)
<< 8U)
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__dataArb_io_out_bits_way_en)
<< 9U)))
| ((0x800U
& (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__dataArb_io_out_bits_eccMask)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__dataArb_io_out_bits_way_en))
<< 8U))
| ((0x400U
& (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__dataArb_io_out_bits_eccMask)
<< 8U)
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__dataArb_io_out_bits_way_en)
<< 7U)))
| ((0x200U
& (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__dataArb_io_out_bits_eccMask)
<< 8U)
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__dataArb_io_out_bits_way_en)
<< 6U)))
| ((0x100U
& (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__dataArb_io_out_bits_eccMask)
<< 8U)
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__dataArb_io_out_bits_way_en)
<< 5U)))
| ((0x80U
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__dataArb_io_out_bits_eccMask)
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__dataArb_io_out_bits_way_en)
<< 5U)))
| ((0x40U
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__dataArb_io_out_bits_eccMask)
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__dataArb_io_out_bits_way_en)
<< 4U)))
| ((0x20U
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__dataArb_io_out_bits_eccMask)
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__dataArb_io_out_bits_way_en)
<< 3U)))
| ((0x10U
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__dataArb_io_out_bits_eccMask)
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__dataArb_io_out_bits_way_en)
<< 2U)))
| ((8U
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__dataArb_io_out_bits_eccMask)
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__dataArb_io_out_bits_way_en)
<< 1U)))
| ((4U
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__dataArb_io_out_bits_eccMask)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__dataArb_io_out_bits_way_en)))
| ((2U
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__dataArb_io_out_bits_eccMask)
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__dataArb_io_out_bits_way_en)
>> 1U)))
| (1U
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__dataArb_io_out_bits_eccMask)
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__dataArb_io_out_bits_way_en)
>> 2U))))))))))))))))));
}
void VTestHarness::_settle__TOP__1010(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1010\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__dataArb__DOT___grant_T_1
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__dataArb__DOT___grant_T)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__dataArb_io_in_2_valid));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache_auto_out_e_valid
= ((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT___T_292))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT___bundleOut_0_e_valid_T_2));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT___GEN_233
= (1U & ((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT___T_292))
& ((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__grantIsCached))
| (((0U != (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__counter))
| (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_e_q__DOT__full)))
& (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT___T_312))))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ll_waddr
= (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT___T_117)
? (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__s2_req_tag)
>> 2U)) : (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__div__DOT__req_tag)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__div_io_resp_ready
= (1U & ((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT___T_117))
& (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__wb_wxd))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__monitor__DOT___T_2170
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__monitor__DOT___a_first_T)
& (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__monitor__DOT__a_first_counter)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__monitor__DOT___T_2250
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__monitor__DOT___a_first_T)
& (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__monitor__DOT__a_first_counter_1)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__tlMasterXbar__DOT___readys_readys_T_2
= (3U & (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__tlMasterXbar__DOT__readys_unready)
>> 2U) & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__tlMasterXbar__DOT__readys_unready)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT__monitor__DOT___T_1070
= (1U & (((0x1fU & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT__monitor__DOT__inflight)
>> (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_source_io_deq_bits_MPORT_data)))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT__monitor__DOT__same_cycle_resp))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_cbus_0_reset_catcher_io_sync_reset)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT__monitor__DOT___T_825
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT__monitor__DOT___T_53)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT__monitor__DOT___T_365))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_cbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT__monitor__DOT___T_498
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT__monitor__DOT___T_53)
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT__monitor__DOT___T_365)
| ((6U >= (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_out_0_a_bits_size))
& (((((0U == (0x7feff000U & vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__out_2_0_a_bits_address))
| (0U == (0x7fff0000U & (0x2000000U
^ vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__out_2_0_a_bits_address))))
| (0U == (0x7ffff000U & (0x2010000U
^ vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__out_2_0_a_bits_address))))
| (0U == (0x7c000000U & (0xc000000U
^ vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__out_2_0_a_bits_address))))
| (0U == (0x7ffff000U & (0x54000000U
^ vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__out_2_0_a_bits_address)))))))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_cbus_0_reset_catcher_io_sync_reset));
}
void VTestHarness::_settle__TOP__1011(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1011\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT__monitor__DOT___T_665
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT__monitor__DOT___T_53)
& ((3U >= (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_out_0_a_bits_size))
& (((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT__monitor__DOT___T_91)
| (0U == (0x7fff0000U & (0x2000000U
^ vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__out_2_0_a_bits_address))))
| (0U == (0x7ffff000U & (0x2010000U
^ vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__out_2_0_a_bits_address))))
| (0U == (0x7c000000U & (0xc000000U
^ vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__out_2_0_a_bits_address))))
| (0U == (0x7ffff000U & (0x54000000U
^ vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__out_2_0_a_bits_address))))))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_cbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT__monitor__DOT__mask
= ((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT__monitor__DOT__mask_acc_5)
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT__monitor__DOT__mask_eq_5)
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__out_2_0_a_bits_address))
<< 7U) | ((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT__monitor__DOT__mask_acc_5)
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT__monitor__DOT__mask_eq_5)
& (~ vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__out_2_0_a_bits_address)))
<< 6U) | ((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT__monitor__DOT__mask_acc_4)
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT__monitor__DOT__mask_eq_4)
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__out_2_0_a_bits_address))
<< 5U) | ((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT__monitor__DOT__mask_acc_4)
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT__monitor__DOT__mask_eq_4)
& (~ vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__out_2_0_a_bits_address)))
<< 4U)
| ((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT__monitor__DOT__mask_acc_3)
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT__monitor__DOT__mask_eq_3)
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__out_2_0_a_bits_address))
<< 3U)
| ((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT__monitor__DOT__mask_acc_3)
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT__monitor__DOT__mask_eq_3)
& (~ vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__out_2_0_a_bits_address)))
<< 2U)
| ((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT__monitor__DOT__mask_acc_2)
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT__monitor__DOT__mask_eq_2)
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__out_2_0_a_bits_address))
<< 1U)
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT__monitor__DOT__mask_acc_2)
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT__monitor__DOT__mask_eq_2)
& (~ vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__out_2_0_a_bits_address))))))))));
}
void VTestHarness::_settle__TOP__1014(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1014\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__request_bits_set
= (0x3ffU & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC_io_req_valid)
? (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__offset
>> 6U) : ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkX__DOT__x__DOT__maybe_full)
? (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkX__DOT__offset
>> 6U) : (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkA__DOT__offset
>> 6U))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__queue_arw_deq_io_deq_ready
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__queue_arw_deq_io_deq_bits_wen)
? ((IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Faw_ready_reg)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT___GEN_79))
: ((IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Far_ready_reg)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT___GEN_15)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__subsystem_mbus_xbar__DOT__monitor__DOT___a_first_T
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__subsystem_mbus_xbar__DOT__monitor_io_in_a_ready)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork_auto_out_a_valid));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__latch
= ((0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__beatsLeft))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__subsystem_mbus_xbar_auto_in_a_ready));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT___beatsLeft_T_4
= (7U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__beatsLeft)
- ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__subsystem_mbus_xbar_auto_in_a_ready)
& ((0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__beatsLeft))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT___T_35)
: (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT___sink_ACancel_earlyValid_T_3)))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__fixer__DOT__monitor__DOT___a_first_T
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__subsystem_mbus_xbar_auto_in_a_ready)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork_auto_out_a_valid));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__binder__DOT__monitor__DOT___a_first_T
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__subsystem_mbus_xbar_auto_in_a_ready)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork_auto_out_a_valid));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__out_ready
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__subsystem_mbus_xbar_auto_in_a_ready)
& ((0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__beatsLeft))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__state___05F0)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__out_1_ready
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__subsystem_mbus_xbar_auto_in_a_ready)
& ((0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__beatsLeft))
? (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT___readys_T_3))
: (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__state___05F1)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__deq__DOT___GEN_9
= ((~ (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fw_ready_reg))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__deq__DOT___do_enq_T));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4_auto_out_aw_valid
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__queue_arw_deq_io_deq_valid)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__queue_arw_deq_io_deq_bits_wen));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4_auto_out_ar_valid
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__queue_arw_deq_io_deq_valid)
& (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__queue_arw_deq_io_deq_bits_wen)));
}
void VTestHarness::_settle__TOP__1015(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1015\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__alu__DOT__shin
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__alu__DOT___shin_T_2)
? vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__alu__DOT__shin_r
: ((VL_ULL(0x5555555555555555) & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__alu__DOT___shin_T_51
>> 1U))
| (VL_ULL(0xaaaaaaaaaaaaaaaa) & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__alu__DOT___shin_T_51
<< 1U))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH
= (0x7fU & (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH2)
>> 7U) | (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH2)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__csr__DOT___io_decode_0_read_illegal_T_282
= ((((((((((((((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__csr__DOT___io_decode_0_read_illegal_T_267)
| (0x141U == (0xfffU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ibuf_io_inst_0_bits_raw
>> 0x14U))))
| (0x105U == (0xfffU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ibuf_io_inst_0_bits_raw
>> 0x14U))))
| (0x106U == (0xfffU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ibuf_io_inst_0_bits_raw
>> 0x14U))))
| (0x303U == (0xfffU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ibuf_io_inst_0_bits_raw
>> 0x14U))))
| (0x302U == (0xfffU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ibuf_io_inst_0_bits_raw
>> 0x14U))))
| (0x3a0U == (0xfffU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ibuf_io_inst_0_bits_raw
>> 0x14U))))
| (0x3a2U == (0xfffU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ibuf_io_inst_0_bits_raw
>> 0x14U))))
| (0x3b0U == (0xfffU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ibuf_io_inst_0_bits_raw
>> 0x14U))))
| (0x3b1U == (0xfffU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ibuf_io_inst_0_bits_raw
>> 0x14U))))
| (0x3b2U == (0xfffU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ibuf_io_inst_0_bits_raw
>> 0x14U))))
| (0x3b3U == (0xfffU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ibuf_io_inst_0_bits_raw
>> 0x14U))))
| (0x3b4U == (0xfffU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ibuf_io_inst_0_bits_raw
>> 0x14U))))
| (0x3b5U == (0xfffU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ibuf_io_inst_0_bits_raw
>> 0x14U)))) |
(0x3b6U == (0xfffU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ibuf_io_inst_0_bits_raw
>> 0x14U)))) | (0x3b7U
==
(0xfffU
& (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ibuf_io_inst_0_bits_raw
>> 0x14U))));
}
void VTestHarness::_settle__TOP__1016(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1016\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ibuf__DOT__exp_io_out_bits
= ((0x1fU == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ibuf__DOT__exp__DOT___io_out_T))
? vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ibuf__DOT__exp_io_in
: ((0x1eU == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ibuf__DOT__exp__DOT___io_out_T))
? vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ibuf__DOT__exp_io_in
: vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ibuf__DOT__exp__DOT___io_out_T_58_bits));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar__DOT___readys_readys_T_2
= (3U & (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar__DOT__readys_unready)
>> 2U) & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar__DOT__readys_unready)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__dtm__DOT___GEN_4
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__dtm__DOT__dmiAccessChain_io_chainIn_capture)
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__dtm__DOT__busy)
: (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__dtm__DOT__stickyBusyReg));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__dtm_io_dmi_resp_ready
= ((2U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__dtm__DOT__dmiReqReg_op))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar_auto_in_d_valid)
: ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__dtm__DOT__dmiAccessChain_io_chainIn_capture)
& (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__dtm__DOT__busy))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__csr__DOT___GEN_182
= ((1U & (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__wb_toint_valid)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_wen))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__wen)))
? ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__csr__DOT__reg_fflags)
| ((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__wb_toint_valid)
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__wb_toint_exc)
: 0U) | ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_wen)
? ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_typeTag)
? (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__divSqrtRecFNToRaw__DOT__divSqrtRawFN___05Fio_invalidExc)
<< 4U) | (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__divSqrtRecFNToRaw__DOT__divSqrtRawFN___05Fio_infiniteExc)
<< 3U)
| (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__overflow)
<< 2U)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__io_exceptionFlags_lo))))
: (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt__DOT__divSqrtRecFNToRaw__DOT__divSqrtRawFN___05Fio_invalidExc)
<< 4U) | (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt__DOT__divSqrtRecFNToRaw__DOT__divSqrtRawFN___05Fio_infiniteExc)
<< 3U)
| (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__overflow)
<< 2U)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__io_exceptionFlags_lo)))))
: 0U)) | ((1U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__wen))
? ((3U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__wbInfo_0_pipeid))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__io_out_b_exc)
: ((2U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__wbInfo_0_pipeid))
?
(((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__fma__DOT__roundRawFNToRecFN_io_invalidExc_b)
<< 4U)
| (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__overflow)
<< 2U)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__io_exceptionFlags_lo)))
:
((1U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__wbInfo_0_pipeid))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__ifpu__DOT__io_out_b_exc)
: (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpmu__DOT__io_out_b_exc))))
: 0U))) : (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__csr__DOT__reg_fflags));
}
void VTestHarness::_settle__TOP__1017(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1017\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Variables
// Begin mtask footprint all:
WData/*95:0*/ __Vtemp1906[3];
// Body
__Vtemp1906[0U] = (IData)((((QData)((IData)((0xfffU
& (((((((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__sRoundedExp)
& (~
(((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__divSqrtRecFNToRaw__DOT__divSqrtRawFN___DOT__isZero_Z)
| VL_GTS_III(1,14,14, 0x3ceU, (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__sRoundedExp)))
? 0xe00U
: 0U)))
& (~
((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__pegMinNonzeroMagOut)
? 0xc31U
: 0U)))
& (~
((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__pegMaxFiniteMagOut)
? 0x400U
: 0U)))
& (~
((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__notNaN_isInfOut)
? 0x200U
: 0U)))
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__pegMinNonzeroMagOut)
? 0x3ceU
: 0U))
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__pegMaxFiniteMagOut)
? 0xbffU
: 0U))
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__notNaN_isInfOut)
? 0xc00U
: 0U))
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__isNaNOut)
? 0xe00U
: 0U)))))
<< 0x34U) | (VL_ULL(0xfffffffffffff)
& (((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__isNaNOut)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__divSqrtRecFNToRaw__DOT__divSqrtRawFN___DOT__isZero_Z))
| VL_GTS_III(1,14,14, 0x3ceU, (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__sRoundedExp)))
?
((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__isNaNOut)
? VL_ULL(0x8000000000000)
: VL_ULL(0))
:
((1U
& (IData)(
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__divSqrtRecFNToRaw__DOT__divSqrtRawFN___05Fio_rawOut_sig
>> 0x37U)))
?
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__roundedSig
>> 1U)
: vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__roundedSig))
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__pegMaxFiniteMagOut)
? VL_ULL(0xfffffffffffff)
: VL_ULL(0))))));
__Vtemp1906[1U] = (IData)(((((QData)((IData)((0xfffU
& (((((((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__sRoundedExp)
& (~
(((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__divSqrtRecFNToRaw__DOT__divSqrtRawFN___DOT__isZero_Z)
| VL_GTS_III(1,14,14, 0x3ceU, (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__sRoundedExp)))
? 0xe00U
: 0U)))
& (~
((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__pegMinNonzeroMagOut)
? 0xc31U
: 0U)))
& (~
((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__pegMaxFiniteMagOut)
? 0x400U
: 0U)))
& (~
((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__notNaN_isInfOut)
? 0x200U
: 0U)))
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__pegMinNonzeroMagOut)
? 0x3ceU
: 0U))
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__pegMaxFiniteMagOut)
? 0xbffU
: 0U))
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__notNaN_isInfOut)
? 0xc00U
: 0U))
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__isNaNOut)
? 0xe00U
: 0U)))))
<< 0x34U) | (VL_ULL(0xfffffffffffff)
& (((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__isNaNOut)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__divSqrtRecFNToRaw__DOT__divSqrtRawFN___DOT__isZero_Z))
| VL_GTS_III(1,14,14, 0x3ceU, (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__sRoundedExp)))
?
((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__isNaNOut)
? VL_ULL(0x8000000000000)
: VL_ULL(0))
:
((1U
& (IData)(
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__divSqrtRecFNToRaw__DOT__divSqrtRawFN___05Fio_rawOut_sig
>> 0x37U)))
?
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__roundedSig
>> 1U)
: vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__roundedSig))
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__pegMaxFiniteMagOut)
? VL_ULL(0xfffffffffffff)
: VL_ULL(0)))))
>> 0x20U));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN_io_out[0U]
= __Vtemp1906[0U];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN_io_out[1U]
= __Vtemp1906[1U];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN_io_out[2U]
= ((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__isNaNOut))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__divSqrtRecFNToRaw__DOT__divSqrtRawFN___DOT__sign_Z));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor__DOT___T_1066
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_in_0_d_bits_sink)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor__DOT__sink))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor__DOT___T_1066
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_io_in_d_bits_sink)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor__DOT__sink))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset));
}
void VTestHarness::_settle__TOP__1018(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1018\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor__DOT___T_1054
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_in_0_d_bits_param)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor__DOT__param_1))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor__DOT___T_1054
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_io_in_d_bits_param)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor__DOT__param_1))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor__DOT___T_951
= (1U & (((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_in_0_d_bits_denied))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_in_0_d_bits_corrupt))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor__DOT___T_1070
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_in_0_d_bits_denied)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor__DOT__denied))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor__DOT___T_951
= (1U & (((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_io_in_d_bits_denied))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_io_in_d_bits_corrupt))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor__DOT___T_1070
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_io_in_d_bits_denied)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor__DOT__denied))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor__DOT___T_1058
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_in_0_d_bits_size)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor__DOT__size_1))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor__DOT___T_1112
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_size_io_deq_bits_MPORT_data)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_in_0_d_bits_size))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor__DOT___T_1124
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_in_0_d_bits_size)
== (0x7fU & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor__DOT__inflight_sizes)
>> 1U))) | (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor__DOT___T_1196
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_in_0_d_bits_size)
== (0x7fU & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor__DOT__inflight_sizes_1)
>> 1U))) | (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor__DOT___T_1058
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_io_in_d_bits_size)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor__DOT__size_1))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset));
}
void VTestHarness::_settle__TOP__1019(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1019\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor__DOT___T_1112
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_size_io_deq_bits_MPORT_data)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_io_in_d_bits_size))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor__DOT___T_1124
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_io_in_d_bits_size)
== (0x7fU & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor__DOT__inflight_sizes)
>> 1U))) | (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor__DOT___T_1196
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_io_in_d_bits_size)
== (0x7fU & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor__DOT__inflight_sizes_1)
>> 1U))) | (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor__DOT___inflight_sizes_T_5
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor__DOT__inflight_sizes_1)
& (~ ((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor__DOT___d_first_T)
& (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor__DOT__d_first_counter_2)))
& (6U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_in_0_d_bits_opcode)))
? 0xffU : 0U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor__DOT___T_1088
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor__DOT___T_1085)
& (6U != (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_in_0_d_bits_opcode)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor__DOT___T_1093
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor__DOT___d_first_T)
& (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor__DOT__d_first_counter_1)))
& (6U != (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_in_0_d_bits_opcode)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor__DOT___T_1050
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_in_0_d_bits_opcode)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor__DOT__opcode_1))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor__DOT___T_1108
= ((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_in_0_d_bits_opcode)
== ((7U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_opcode_io_deq_bits_MPORT_data))
? 4U : ((6U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_opcode_io_deq_bits_MPORT_data))
? 4U : (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor__DOT___GEN_30))))
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_in_0_d_bits_opcode)
== ((7U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_opcode_io_deq_bits_MPORT_data))
? 4U : ((6U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_opcode_io_deq_bits_MPORT_data))
? 5U : (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor__DOT___GEN_30)))))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset));
}
void VTestHarness::_settle__TOP__1020(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1020\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor__DOT___T_1120
= ((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_in_0_d_bits_opcode)
== ((7U == (7U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor__DOT__inflight_opcodes)
>> 1U))) ? 4U : ((6U
==
(7U
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor__DOT__inflight_opcodes)
>> 1U)))
? 4U
: (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor__DOT___GEN_46))))
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_in_0_d_bits_opcode)
== ((7U == (7U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor__DOT__inflight_opcodes)
>> 1U))) ? 4U : ((6U
==
(7U
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor__DOT__inflight_opcodes)
>> 1U)))
? 5U
: (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor__DOT___GEN_46)))))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor__DOT___inflight_sizes_T_5
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor__DOT__inflight_sizes_1)
& (~ ((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor__DOT___d_first_T)
& (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor__DOT__d_first_counter_2)))
& (6U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_io_in_d_bits_opcode)))
? 0xffU : 0U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor__DOT___T_1088
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor__DOT___T_1085)
& (6U != (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_io_in_d_bits_opcode)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor__DOT___T_1093
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor__DOT___d_first_T)
& (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor__DOT__d_first_counter_1)))
& (6U != (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_io_in_d_bits_opcode)));
}
void VTestHarness::_settle__TOP__1021(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1021\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor__DOT___T_1050
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_io_in_d_bits_opcode)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor__DOT__opcode_1))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor__DOT___T_1108
= ((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_io_in_d_bits_opcode)
== ((7U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_opcode_io_deq_bits_MPORT_data))
? 4U : ((6U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_opcode_io_deq_bits_MPORT_data))
? 4U : (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor__DOT___GEN_30))))
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_io_in_d_bits_opcode)
== ((7U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_opcode_io_deq_bits_MPORT_data))
? 4U : ((6U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_opcode_io_deq_bits_MPORT_data))
? 5U : (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor__DOT___GEN_30)))))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor__DOT___T_1120
= ((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_io_in_d_bits_opcode)
== ((7U == (7U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor__DOT__inflight_opcodes)
>> 1U))) ? 4U : ((6U
==
(7U
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor__DOT__inflight_opcodes)
>> 1U)))
? 4U
: (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor__DOT___GEN_46))))
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_io_in_d_bits_opcode)
== ((7U == (7U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor__DOT__inflight_opcodes)
>> 1U))) ? 4U : ((6U
==
(7U
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor__DOT__inflight_opcodes)
>> 1U)))
? 5U
: (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor__DOT___GEN_46)))))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset));
}
void VTestHarness::_settle__TOP__1022(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1022\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Variables
// Begin mtask footprint all:
WData/*95:0*/ __Vtemp1908[3];
WData/*95:0*/ __Vtemp1909[3];
WData/*95:0*/ __Vtemp1914[3];
WData/*95:0*/ __Vtemp1915[3];
WData/*95:0*/ __Vtemp1920[3];
WData/*95:0*/ __Vtemp1921[3];
// Body
VL_EXTEND_WI(67,4, __Vtemp1908, ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__monitor__DOT___T_1330)
? (1U | ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_out_1_a_bits_opcode)
<< 1U))
: 0U));
VL_SHIFTL_WWI(67,67,6, __Vtemp1909, __Vtemp1908,
((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_out_1_a_bits_source)
<< 2U));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__monitor__DOT___inflight_opcodes_T_2
= (0xfffffU & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__monitor__DOT__inflight_opcodes
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__monitor__DOT___T_1330)
? __Vtemp1909[0U] : 0U))
& (~ vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__monitor__DOT___GEN_35[0U])));
VL_EXTEND_WI(67,4, __Vtemp1914, ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__monitor__DOT___T_1330)
? (1U | (0xeU
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__out_2_1_a_bits_size)
<< 1U)))
: 0U));
VL_SHIFTL_WWI(67,67,6, __Vtemp1915, __Vtemp1914,
((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_out_1_a_bits_source)
<< 2U));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__monitor__DOT___inflight_sizes_T_2
= (0xfffffU & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__monitor__DOT__inflight_sizes
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__monitor__DOT___T_1330)
? __Vtemp1915[0U] : 0U))
& (~ vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__monitor__DOT___GEN_35[0U])));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__monitor__DOT___inflight_T_5
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__monitor__DOT__inflight_1)
& (~ ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__monitor__DOT___T_1160)
? (0xffU & ((IData)(1U) << (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_source_io_deq_bits_MPORT_data)))
: 0U)));
__Vtemp1920[0U] = 0xffU;
__Vtemp1920[1U] = 0U;
__Vtemp1920[2U] = 0U;
VL_SHIFTL_WWI(79,79,6, __Vtemp1921, __Vtemp1920,
((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_source_io_deq_bits_MPORT_data)
<< 3U));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__monitor__DOT___inflight_sizes_T_5
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__monitor__DOT__inflight_sizes_1
& (~ (((QData)((IData)(((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__monitor__DOT___T_1160)
? __Vtemp1921[1U]
: 0U))) << 0x20U)
| (QData)((IData)(((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__monitor__DOT___T_1160)
? __Vtemp1921[0U]
: 0U))))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___T_2179
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_in_1_d_bits_param)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT__param_1))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___T_2179
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1_io_in_d_bits_param)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT__param_1))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset));
}
void VTestHarness::_settle__TOP__1023(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1023\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___T_1019
= (1U & (((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_in_1_d_bits_denied))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_in_1_d_bits_corrupt))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___T_2195
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_in_1_d_bits_denied)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT__denied))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___T_1019
= (1U & (((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1_io_in_d_bits_denied))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1_io_in_d_bits_corrupt))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___T_2195
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1_io_in_d_bits_denied)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT__denied))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___T_2183
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_in_1_d_bits_size)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT__size_1))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___T_2285
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_a_q__DOT__ram_size_io_deq_bits_MPORT_data)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_in_1_d_bits_size))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___T_2365
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_in_1_d_bits_size)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_c_q__DOT__ram_size_io_deq_bits_MPORT_data))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___T_2297
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_in_1_d_bits_size)
== (0x7fU & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT__inflight_sizes
>> (0x18U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__sink_ACancel_7_bits_source)
<< 3U))) >> 1U)))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___T_2369
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_in_1_d_bits_size)
== (0x7fU & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT__inflight_sizes_1
>> (0x18U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__sink_ACancel_7_bits_source)
<< 3U))) >> 1U)))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___T_2183
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1_io_in_d_bits_size)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT__size_1))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset));
}
void VTestHarness::_settle__TOP__1024(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1024\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___T_2285
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_a_q__DOT__ram_size_io_deq_bits_MPORT_data)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1_io_in_d_bits_size))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___T_2365
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1_io_in_d_bits_size)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_c_q__DOT__ram_size_io_deq_bits_MPORT_data))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___T_2297
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1_io_in_d_bits_size)
== (0x7fU & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT__inflight_sizes
>> (0x18U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__sink_ACancel_7_bits_source)
<< 3U))) >> 1U)))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___T_2369
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1_io_in_d_bits_size)
== (0x7fU & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT__inflight_sizes_1
>> (0x18U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__sink_ACancel_7_bits_source)
<< 3U))) >> 1U)))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___T_2191
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_in_1_d_bits_sink)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT__sink))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___T_2410
= (1U & ((~ (0xffU & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT__inflight_2)
>> (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_in_1_d_bits_sink))))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___T_2191
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1_io_in_d_bits_sink)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT__sink))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___T_2410
= (1U & ((~ (0xffU & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT__inflight_2)
>> (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1_io_in_d_bits_sink))))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT__same_cycle_resp
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___T_2247)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___same_cycle_resp_T_2));
}
void VTestHarness::_settle__TOP__1025(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1025\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT__same_cycle_resp_1
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___T_2334)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___same_cycle_resp_T_8));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT__same_cycle_resp
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___T_2247)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___same_cycle_resp_T_2));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT__same_cycle_resp_1
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___T_2334)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___same_cycle_resp_T_8));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___GEN_58
= ((5U == (7U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___a_opcode_lookup_T_1)
>> 1U))) ? 2U : ((4U == (7U
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___a_opcode_lookup_T_1)
>> 1U)))
? 1U : (
(3U
==
(7U
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___a_opcode_lookup_T_1)
>> 1U)))
? 1U
:
((2U
==
(7U
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___a_opcode_lookup_T_1)
>> 1U)))
? 1U
: 0U))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___GEN_58
= ((5U == (7U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___a_opcode_lookup_T_1)
>> 1U))) ? 2U : ((4U == (7U
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___a_opcode_lookup_T_1)
>> 1U)))
? 1U : (
(3U
==
(7U
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___a_opcode_lookup_T_1)
>> 1U)))
? 1U
:
((2U
==
(7U
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___a_opcode_lookup_T_1)
>> 1U)))
? 1U
: 0U))));
}
void VTestHarness::_settle__TOP__1026(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1026\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___T_2261
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___T_2258)
& (6U != (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_in_1_d_bits_opcode)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___T_2349
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___T_2347)
& (6U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_in_1_d_bits_opcode)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT__d_set
= ((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___d_first_T)
& (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT__d_first_counter_3)))
& (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_in_1_d_bits_opcode)
>> 2U) & (~ ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_in_1_d_bits_opcode)
>> 1U)))) ? (0xffU & ((IData)(1U)
<< (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_in_1_d_bits_sink)))
: 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___T_2353
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___d_first_T)
& (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT__d_first_counter_2)))
& (6U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_in_1_d_bits_opcode)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___T_2266
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___d_first_T)
& (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT__d_first_counter_1)))
& (6U != (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_in_1_d_bits_opcode)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___T_2175
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_in_1_d_bits_opcode)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT__opcode_1))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___T_2281
= ((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_in_1_d_bits_opcode)
== ((7U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_a_q__DOT__ram_opcode_io_deq_bits_MPORT_data))
? 4U : ((6U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_a_q__DOT__ram_opcode_io_deq_bits_MPORT_data))
? 4U : (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___GEN_42))))
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_in_1_d_bits_opcode)
== ((7U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_a_q__DOT__ram_opcode_io_deq_bits_MPORT_data))
? 4U : ((6U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_a_q__DOT__ram_opcode_io_deq_bits_MPORT_data))
? 5U : (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___GEN_42)))))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___T_2261
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___T_2258)
& (6U != (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1_io_in_d_bits_opcode)));
}
void VTestHarness::_settle__TOP__1027(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1027\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___T_2349
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___T_2347)
& (6U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1_io_in_d_bits_opcode)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT__d_set
= ((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___d_first_T)
& (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT__d_first_counter_3)))
& (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1_io_in_d_bits_opcode)
>> 2U) & (~ ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1_io_in_d_bits_opcode)
>> 1U)))) ? (0xffU & ((IData)(1U)
<< (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1_io_in_d_bits_sink)))
: 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___T_2353
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___d_first_T)
& (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT__d_first_counter_2)))
& (6U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1_io_in_d_bits_opcode)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___T_2266
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___d_first_T)
& (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT__d_first_counter_1)))
& (6U != (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1_io_in_d_bits_opcode)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___T_2175
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1_io_in_d_bits_opcode)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT__opcode_1))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___T_2281
= ((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1_io_in_d_bits_opcode)
== ((7U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_a_q__DOT__ram_opcode_io_deq_bits_MPORT_data))
? 4U : ((6U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_a_q__DOT__ram_opcode_io_deq_bits_MPORT_data))
? 4U : (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___GEN_42))))
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1_io_in_d_bits_opcode)
== ((7U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_a_q__DOT__ram_opcode_io_deq_bits_MPORT_data))
? 4U : ((6U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_a_q__DOT__ram_opcode_io_deq_bits_MPORT_data))
? 5U : (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___GEN_42)))))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__fragmenter__DOT__monitor__DOT___inflight_T_5
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__fragmenter__DOT__monitor__DOT__inflight_1)
& (~ ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__fragmenter__DOT__monitor__DOT___T_754)
? (0xffU & ((IData)(1U) << (7U &
((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_source_io_deq_bits_MPORT_data)
>> 4U))))
: 0U)));
}
void VTestHarness::_settle__TOP__1028(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1028\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Variables
// Begin mtask footprint all:
WData/*95:0*/ __Vtemp1926[3];
WData/*95:0*/ __Vtemp1927[3];
WData/*95:0*/ __Vtemp1932[3];
WData/*95:0*/ __Vtemp1933[3];
WData/*95:0*/ __Vtemp1938[3];
WData/*95:0*/ __Vtemp1939[3];
// Body
__Vtemp1926[0U] = 0xfU;
__Vtemp1926[1U] = 0U;
__Vtemp1926[2U] = 0U;
VL_SHIFTL_WWI(79,79,6, __Vtemp1927, __Vtemp1926,
(0x1cU & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_source_io_deq_bits_MPORT_data)
>> 2U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__fragmenter__DOT__monitor__DOT___inflight_sizes_T_5
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__fragmenter__DOT__monitor__DOT__inflight_sizes_1
& (~ ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__fragmenter__DOT__monitor__DOT___T_754)
? __Vtemp1927[0U] : 0U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__fragmenter__DOT__monitor__DOT___inflight_T_2
= (0x1fU & (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__fragmenter__DOT__monitor__DOT__inflight)
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__fragmenter__DOT__monitor__DOT___T_651)
? (0xffU & ((IData)(1U) << (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_source_io_deq_bits_MPORT_data)))
: 0U)) & (~ ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__fragmenter__DOT__monitor__DOT___T_667)
? (0xffU & ((IData)(1U)
<<
(7U
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_source_io_deq_bits_MPORT_data)
>> 4U))))
: 0U))));
__Vtemp1932[0U] = 0xfU;
__Vtemp1932[1U] = 0U;
__Vtemp1932[2U] = 0U;
VL_SHIFTL_WWI(79,79,6, __Vtemp1933, __Vtemp1932,
(0x1cU & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_source_io_deq_bits_MPORT_data)
>> 2U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__fragmenter__DOT__monitor__DOT___GEN_23[0U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__fragmenter__DOT__monitor__DOT___T_667)
? __Vtemp1933[0U] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__fragmenter__DOT__monitor__DOT___GEN_23[1U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__fragmenter__DOT__monitor__DOT___T_667)
? __Vtemp1933[1U] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__fragmenter__DOT__monitor__DOT___GEN_23[2U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__fragmenter__DOT__monitor__DOT___T_667)
? (0x7fffU & __Vtemp1933[2U]) : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_593
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT__d_first_done)
& (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT__d_first_counter)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_700
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT__d_first_done)
& (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT__d_first_counter_2)))
& (6U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_opcode_io_deq_bits_MPORT_data)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_613
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT__d_first_done)
& (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT__d_first_counter_1)))
& (6U != (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_opcode_io_deq_bits_MPORT_data)));
__Vtemp1938[0U] = 0xfU;
__Vtemp1938[1U] = 0U;
__Vtemp1938[2U] = 0U;
VL_SHIFTL_WWI(79,79,6, __Vtemp1939, __Vtemp1938,
(0x1cU & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter_auto_out_a_bits_source)
>> 2U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__monitor__DOT___GEN_23[0U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__monitor__DOT___T_667)
? __Vtemp1939[0U] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__monitor__DOT___GEN_23[1U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__monitor__DOT___T_667)
? __Vtemp1939[1U] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__monitor__DOT___GEN_23[2U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__monitor__DOT___T_667)
? (0x7fffU & __Vtemp1939[2U]) : 0U);
}
void VTestHarness::_settle__TOP__1029(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1029\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___T_565
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT__a_first_done)
& (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT__a_first_counter)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___T_597
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT__a_first_done)
& (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT__a_first_counter_1)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___T_593
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT__d_first_done)
& (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT__d_first_counter)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___T_610
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT__d_first_done)
& (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT__d_first_counter_1)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__rxq__DOT__do_deq
= (0xfU & ((((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT___out_rifireMux_T)
& (4U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__repeater_io_deq_bits_opcode)))
& ((IData)(1U) << (3U & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter_auto_out_a_bits_address
>> 3U))))
& (0U == (0x1fcU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter_auto_out_a_bits_address
>> 3U))))
& (0U != (0xffU & (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__out_frontMask
>> 0x20U)))))
& (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__rxq__DOT__empty))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT___out_wifireMux_T_2
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT___out_rifireMux_T)
& (4U != (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__repeater_io_deq_bits_opcode)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__monitor__DOT___T_710
= (1U & (((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar_auto_out_0_d_ready))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__repeater_io_enq_ready))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_pbus_0_reset_catcher_io_sync_reset)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__repeater__DOT___T_1
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__repeater_io_enq_ready)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar_auto_out_0_a_valid))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__repeater_io_repeat));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__monitor__DOT___a_first_T
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__repeater_io_enq_ready)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar_auto_out_0_a_valid));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT___portsAOI_in_0_a_ready_T
= ((0U == (0x40000000U & (0x40000000U ^ vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_address_io_deq_bits_MPORT_data)))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__repeater_io_enq_ready));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__monitor__DOT___T_688
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar_auto_in_d_bits_param)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__monitor__DOT__param_1))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_pbus_0_reset_catcher_io_sync_reset));
}
void VTestHarness::_settle__TOP__1030(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1030\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__monitor__DOT___T_700
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar_auto_in_d_bits_sink)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__monitor__DOT__sink))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_pbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__monitor__DOT___T_688
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__monitor_io_in_d_bits_param)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__monitor__DOT__param_1))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_pbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__monitor__DOT___T_700
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__monitor_io_in_d_bits_sink)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__monitor__DOT__sink))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_pbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__monitor__DOT___T_585
= (1U & (((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar_auto_in_d_bits_denied))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar_auto_in_d_bits_corrupt))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_pbus_0_reset_catcher_io_sync_reset)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__monitor__DOT___T_704
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar_auto_in_d_bits_denied)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__monitor__DOT__denied))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_pbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__monitor__DOT___T_585
= (1U & (((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__monitor_io_in_d_bits_denied))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__monitor_io_in_d_bits_corrupt))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_pbus_0_reset_catcher_io_sync_reset)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__monitor__DOT___T_704
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__monitor_io_in_d_bits_denied)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__monitor__DOT__denied))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_pbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar_auto_in_d_bits_size
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT___T_39)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT___T_40));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__monitor_io_in_d_bits_size
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT___T_39)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT___T_40));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar_auto_in_d_bits_opcode
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT___T_45)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT___T_46));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__monitor_io_in_d_bits_opcode
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT___T_45)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT___T_46));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar_auto_in_d_bits_source
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT___T_36)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT___T_37));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__monitor_io_in_d_bits_source
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT___T_36)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT___T_37));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ibuf__DOT___io_imem_ready_T_4
= (3U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ibuf__DOT__nIC)
- (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ibuf__DOT__nICReady)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__mem_wrong_npc
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ex_pc_valid)
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT___mem_wrong_npc_T)
: (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT___mem_wrong_npc_T_3));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar__DOT___readys_mask_T_3
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar__DOT___readys_mask_T)
| (0x7eU & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar__DOT___readys_mask_T)
<< 1U)));
}
void VTestHarness::_settle__TOP__1031(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1031\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__bundleIn_0_d_q__DOT__do_deq
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar_auto_out_0_d_ready)
& (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__bundleIn_0_d_q__DOT__empty)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__monitor__DOT___T_719
= (1U & (((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar_auto_out_0_d_ready))
| (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__bundleOut_0_a_q__DOT__full)))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_cbus_0_reset_catcher_io_sync_reset)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__monitor__DOT___d_first_T
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar_auto_out_0_d_ready)
& (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__bundleIn_0_d_q__DOT__empty)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__bundleIn_0_d_q__DOT__do_deq
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar_auto_out_2_d_ready)
& (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__bundleIn_0_d_q__DOT__empty)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__monitor__DOT___T_776
= (1U & (((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar_auto_out_2_d_ready))
| (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__bundleOut_0_a_q__DOT__full)))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_pbus_0_reset_catcher_io_sync_reset)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__monitor__DOT___d_first_T
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar_auto_out_2_d_ready)
& (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__bundleIn_0_d_q__DOT__empty)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__fragmenter__DOT___T_7
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar_auto_out_1_d_ready)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__fragmenter__DOT__drop))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__maybe_full));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__fragmenter__DOT__monitor__DOT___T_710
= (1U & (((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar_auto_out_1_d_ready))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__fragmenter__DOT__repeater_io_enq_ready))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_cbus_0_reset_catcher_io_sync_reset)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__fragmenter__DOT__monitor__DOT___d_first_T
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar_auto_out_1_d_ready)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__fragmenter__DOT__monitor_io_in_d_valid));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__fragmenter_auto_out_d_ready
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar_auto_out_1_d_ready)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__fragmenter__DOT__drop));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_plic__DOT__fragmenter__DOT___T_7
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar_auto_out_3_d_ready)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_plic__DOT__fragmenter__DOT__drop))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__plicDomainWrapper__DOT__plic__DOT__out_back__DOT__maybe_full));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_plic__DOT__fragmenter__DOT__monitor__DOT___T_710
= (1U & (((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar_auto_out_3_d_ready))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_plic__DOT__fragmenter__DOT__repeater_io_enq_ready))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_cbus_0_reset_catcher_io_sync_reset)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_plic__DOT__fragmenter__DOT__monitor__DOT___d_first_T
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar_auto_out_3_d_ready)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_plic__DOT__fragmenter__DOT__monitor_io_in_d_valid));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_plic__DOT__fragmenter_auto_out_d_ready
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar_auto_out_3_d_ready)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_plic__DOT__fragmenter__DOT__drop));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_bootrom__DOT__fragmenter__DOT___T_7
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar_auto_out_6_d_ready)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_bootrom__DOT__fragmenter__DOT__repeater_io_deq_valid));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__bootROMDomainWrapper__DOT__bootrom__DOT__monitor__DOT___T_650
= (1U & (((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar_auto_out_6_d_ready))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar_auto_out_6_d_ready))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_cbus_0_reset_catcher_io_sync_reset)));
}
void VTestHarness::_settle__TOP__1032(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1032\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__bootROMDomainWrapper__DOT__bootrom__DOT__monitor__DOT__a_first_done
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar_auto_out_6_d_ready)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_bootrom__DOT__fragmenter__DOT__repeater_io_deq_valid));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__bootROMDomainWrapper__DOT__bootrom__DOT__monitor__DOT__d_first_done
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar_auto_out_6_d_ready)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_bootrom__DOT__fragmenter__DOT__repeater_io_deq_valid));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_bootrom__DOT__fragmenter__DOT__monitor__DOT___d_first_T
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar_auto_out_6_d_ready)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_bootrom__DOT__fragmenter__DOT__repeater_io_deq_valid));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_bootrom__DOT__fragmenter__DOT__repeater_io_enq_ready
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar_auto_out_6_d_ready)
& (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_bootrom__DOT__fragmenter__DOT__repeater__DOT__full)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar__DOT__muxStateEarly_6
= ((0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar__DOT__beatsLeft))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar__DOT__earlyWinner_6)
: (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar__DOT__state_6));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar__DOT__muxStateEarly_5
= ((0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar__DOT__beatsLeft))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar__DOT__earlyWinner_5)
: (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar__DOT__state_5));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar__DOT__muxStateEarly_4
= ((0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar__DOT__beatsLeft))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar__DOT__earlyWinner_4)
: (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar__DOT__state_4));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar__DOT__muxStateEarly_3
= ((0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar__DOT__beatsLeft))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar__DOT__earlyWinner_3)
: (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar__DOT__state_3));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar__DOT__muxStateEarly_2
= ((0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar__DOT__beatsLeft))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar__DOT__earlyWinner_2)
: (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar__DOT__state_2));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_debug__DOT__fragmenter__DOT___T_7
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar_auto_out_5_d_ready)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_debug__DOT__fragmenter__DOT__drop))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_debug__DOT__fragmenter__DOT__repeater_io_deq_valid));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_debug__DOT__fragmenter__DOT__monitor__DOT___d_first_T
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar_auto_out_5_d_ready)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_debug__DOT__fragmenter__DOT__monitor_io_in_d_valid));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_debug__DOT__fragmenter_auto_out_d_ready
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar_auto_out_5_d_ready)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_debug__DOT__fragmenter__DOT__drop));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar__DOT__muxStateEarly_0
= ((0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar__DOT__beatsLeft))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar__DOT__earlyWinner_0)
: (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar__DOT__state_0));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar__DOT___initBeats_T_4
= (0x1ffU & (((((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar__DOT__earlyWinner_0)
? ((1U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_opcode_io_deq_bits_MPORT_data))
? (~ (0xffffffU & (((IData)(0xfffU)
<< (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_size_io_deq_bits_MPORT_data))
>> 3U)))
: 0U) : 0U) | ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar__DOT__earlyWinner_1)
? ((1U
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_opcode
[0U])
?
(7U
& (~
(0x3ffffU
& (((IData)(0x3fU)
<< (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__fragmenter_auto_in_d_bits_size))
>> 3U))))
: 0U)
: 0U))
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar__DOT__earlyWinner_2)
? ((1U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__bundleIn_0_d_q__DOT__ram_opcode_io_deq_bits_MPORT_data))
? (7U & (~ (0x3ffffU
& (((IData)(0x3fU)
<< (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__bundleIn_0_d_q__DOT__ram_size_io_deq_bits_MPORT_data))
>> 3U))))
: 0U) : 0U)) | ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar__DOT__earlyWinner_3)
?
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__plicDomainWrapper__DOT__plic__DOT__out_back__DOT__ram_read
[0U]
?
(7U
& (~
(0x3ffffU
& (((IData)(0x3fU)
<< (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_plic__DOT__fragmenter_auto_in_d_bits_size))
>> 3U))))
: 0U)
: 0U))
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar__DOT__earlyWinner_4)
? ((4U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_clint__DOT__fragmenter__DOT__repeater_io_deq_bits_opcode))
? (7U & (~ (0x3ffffU
& (((IData)(0x3fU)
<< (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_clint__DOT__fragmenter_auto_in_d_bits_size))
>> 3U))))
: 0U) : 0U)) | ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar__DOT__earlyWinner_5)
? ((4U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_debug__DOT__fragmenter__DOT__repeater_io_deq_bits_opcode))
?
(7U
& (~
(0x3ffffU
& (((IData)(0x3fU)
<< (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_debug__DOT__fragmenter_auto_in_d_bits_size))
>> 3U))))
: 0U)
: 0U)));
}
void VTestHarness::_settle__TOP__1033(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1033\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar__DOT__prefixOR_2
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar__DOT__earlyWinner_0)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar__DOT__earlyWinner_1));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar__DOT__muxStateEarly_1
= ((0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar__DOT__beatsLeft))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar__DOT__earlyWinner_1)
: (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar__DOT__state_1));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_clint__DOT__fragmenter__DOT___T_7
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar_auto_out_4_d_ready)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_clint__DOT__fragmenter__DOT__drop))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_clint__DOT__fragmenter__DOT__repeater_io_deq_valid));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_clint__DOT__fragmenter__DOT__monitor__DOT___d_first_T
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar_auto_out_4_d_ready)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_clint__DOT__fragmenter__DOT__monitor_io_in_d_valid));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_clint__DOT__fragmenter_auto_out_d_ready
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__out_xbar_auto_out_4_d_ready)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_clint__DOT__fragmenter__DOT__drop));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmInner__DOT__dmInner__DOT___GEN_1883
= ((0x75U == (0xffU & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_debug__DOT__fragmenter_auto_out_a_bits_address)
>> 3U))) ? VL_ULL(0)
: ((0x74U == (0xffU & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_debug__DOT__fragmenter_auto_out_a_bits_address)
>> 3U))) ? VL_ULL(0)
: ((0x73U == (0xffU & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_debug__DOT__fragmenter_auto_out_a_bits_address)
>> 3U))) ? VL_ULL(0)
: ((0x72U == (0xffU & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_debug__DOT__fragmenter_auto_out_a_bits_address)
>> 3U)))
? VL_ULL(0) : ((0x71U == (0xffU
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_debug__DOT__fragmenter_auto_out_a_bits_address)
>> 3U)))
? VL_ULL(0)
: ((0x70U ==
(0xffU
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_debug__DOT__fragmenter_auto_out_a_bits_address)
>> 3U)))
? (((QData)((IData)(
(((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmInner__DOT__dmInner__DOT__abstractDataMem_7)
<< 0x18U)
| (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmInner__DOT__dmInner__DOT__abstractDataMem_6)
<< 0x10U)
| (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmInner__DOT__dmInner__DOT__abstractDataMem_5)
<< 8U)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmInner__DOT__dmInner__DOT__abstractDataMem_4))))))
<< 0x20U)
| (QData)((IData)(
(((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmInner__DOT__dmInner__DOT__abstractDataMem_3)
<< 0x18U)
| (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmInner__DOT__dmInner__DOT__abstractDataMem_2)
<< 0x10U)
| (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmInner__DOT__dmInner__DOT__abstractDataMem_1)
<< 8U)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmInner__DOT__dmInner__DOT__abstractDataMem_0)))))))
: ((0x6fU
==
(0xffU
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_debug__DOT__fragmenter_auto_out_a_bits_address)
>> 3U)))
? (
((QData)((IData)(
(((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmInner__DOT__dmInner__DOT__programBufferMem_63)
<< 0x18U)
| (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmInner__DOT__dmInner__DOT__programBufferMem_62)
<< 0x10U)
| (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmInner__DOT__dmInner__DOT__programBufferMem_61)
<< 8U)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmInner__DOT__dmInner__DOT__programBufferMem_60))))))
<< 0x20U)
| (QData)((IData)(
(((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmInner__DOT__dmInner__DOT__programBufferMem_59)
<< 0x18U)
| (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmInner__DOT__dmInner__DOT__programBufferMem_58)
<< 0x10U)
| (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmInner__DOT__dmInner__DOT__programBufferMem_57)
<< 8U)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmInner__DOT__dmInner__DOT__programBufferMem_56)))))))
: (
(0x6eU
==
(0xffU
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_debug__DOT__fragmenter_auto_out_a_bits_address)
>> 3U)))
?
(((QData)((IData)(
(((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmInner__DOT__dmInner__DOT__programBufferMem_55)
<< 0x18U)
| (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmInner__DOT__dmInner__DOT__programBufferMem_54)
<< 0x10U)
| (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmInner__DOT__dmInner__DOT__programBufferMem_53)
<< 8U)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmInner__DOT__dmInner__DOT__programBufferMem_52))))))
<< 0x20U)
| (QData)((IData)(
(((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmInner__DOT__dmInner__DOT__programBufferMem_51)
<< 0x18U)
| (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmInner__DOT__dmInner__DOT__programBufferMem_50)
<< 0x10U)
| (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmInner__DOT__dmInner__DOT__programBufferMem_49)
<< 8U)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmInner__DOT__dmInner__DOT__programBufferMem_48)))))))
: vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmInner__DOT__dmInner__DOT___GEN_1875))))))));
}
void VTestHarness::_settle__TOP__1034(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1034\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmInner__DOT__dmInner__DOT___GEN_1644
= ((0x86U == (0xffU & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_debug__DOT__fragmenter_auto_out_a_bits_address)
>> 3U))) ? (0U == (0x100U
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_debug__DOT__fragmenter_auto_out_a_bits_address)
>> 3U)))
: ((0x85U == (0xffU & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_debug__DOT__fragmenter_auto_out_a_bits_address)
>> 3U))) ? (0U ==
(0x100U
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_debug__DOT__fragmenter_auto_out_a_bits_address)
>> 3U)))
: ((0x84U == (0xffU & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_debug__DOT__fragmenter_auto_out_a_bits_address)
>> 3U))) ? (0U
==
(0x100U
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_debug__DOT__fragmenter_auto_out_a_bits_address)
>> 3U)))
: ((0x83U == (0xffU & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_debug__DOT__fragmenter_auto_out_a_bits_address)
>> 3U)))
? (0U == (0x100U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_debug__DOT__fragmenter_auto_out_a_bits_address)
>> 3U)))
: ((0x82U == (0xffU & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_debug__DOT__fragmenter_auto_out_a_bits_address)
>> 3U)))
? (0U == (0x100U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_debug__DOT__fragmenter_auto_out_a_bits_address)
>> 3U)))
: ((0x81U == (0xffU & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_debug__DOT__fragmenter_auto_out_a_bits_address)
>> 3U)))
? (0U == (0x100U &
((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_debug__DOT__fragmenter_auto_out_a_bits_address)
>> 3U)))
: ((0x80U == (0xffU
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_debug__DOT__fragmenter_auto_out_a_bits_address)
>> 3U)))
? (0U == (0x100U
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_debug__DOT__fragmenter_auto_out_a_bits_address)
>> 3U)))
: (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmInner__DOT__dmInner__DOT___GEN_1637))))))));
}
void VTestHarness::_settle__TOP__1035(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1035\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__bootROMDomainWrapper__DOT__bootrom__DOT___GEN_130
= ((0x82U == (0x1ffU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_bootrom__DOT__fragmenter_auto_out_a_bits_address
>> 3U))) ? VL_ULL(0x30303030303030)
: ((0x81U == (0x1ffU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_bootrom__DOT__fragmenter_auto_out_a_bits_address
>> 3U))) ? VL_ULL(0x384079726f6d656d)
: ((0x80U == (0x1ffU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_bootrom__DOT__fragmenter_auto_out_a_bits_address
>> 3U))) ? VL_ULL(0x100000002000000)
: ((0x7fU == (0x1ffU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_bootrom__DOT__fragmenter_auto_out_a_bits_address
>> 3U)))
? VL_ULL(0x3066697468) : ((0x7eU
==
(0x1ffU
& (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_bootrom__DOT__fragmenter_auto_out_a_bits_address
>> 3U)))
? VL_ULL(0x2c6263751b000000)
:
((0x7dU
==
(0x1ffU
& (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_bootrom__DOT__fragmenter_auto_out_a_bits_address
>> 3U)))
? VL_ULL(0xa00000003000000)
:
((0x7cU
==
(0x1ffU
& (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_bootrom__DOT__fragmenter_auto_out_a_bits_address
>> 3U)))
? VL_ULL(0x66697468)
:
((0x7bU
==
(0x1ffU
& (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_bootrom__DOT__fragmenter_auto_out_a_bits_address
>> 3U)))
? VL_ULL(0x100000002000000)
:
((0x7aU
==
(0x1ffU
& (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_bootrom__DOT__fragmenter_auto_out_a_bits_address
>> 3U)))
? VL_ULL(0x200000002000000)
:
((0x79U
==
(0x1ffU
& (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_bootrom__DOT__fragmenter_auto_out_a_bits_address
>> 3U)))
? VL_ULL(0x40000008d010000)
:
((0x78U
==
(0x1ffU
& (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_bootrom__DOT__fragmenter_auto_out_a_bits_address
>> 3U)))
? VL_ULL(0x400000003000000)
:
((0x77U
==
(0x1ffU
& (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_bootrom__DOT__fragmenter_auto_out_a_bits_address
>> 3U)))
? VL_ULL(0x7801000000000000)
:
((0x76U
==
(0x1ffU
& (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_bootrom__DOT__fragmenter_auto_out_a_bits_address
>> 3U)))
? VL_ULL(0x300000000006374)
: vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__bootROMDomainWrapper__DOT__bootrom__DOT___GEN_117)))))))))))));
}
void VTestHarness::_settle__TOP__1036(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1036\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Variables
// Begin mtask footprint all:
WData/*95:0*/ __Vtemp1943[3];
// Body
__Vtemp1943[0U] = (IData)((((QData)((IData)((0xfffU
& (((((((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__sRoundedExp)
& (~
(((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN_io_in_b_isZero)
| VL_GTS_III(1,14,14, 0x3ceU, (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__sRoundedExp)))
? 0xe00U
: 0U)))
& (~
((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__pegMinNonzeroMagOut)
? 0xc31U
: 0U)))
& (~
((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__pegMaxFiniteMagOut)
? 0x400U
: 0U)))
& (~
((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__notNaN_isInfOut)
? 0x200U
: 0U)))
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__pegMinNonzeroMagOut)
? 0x3ceU
: 0U))
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__pegMaxFiniteMagOut)
? 0xbffU
: 0U))
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__notNaN_isInfOut)
? 0xc00U
: 0U))
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__isNaNOut)
? 0xe00U
: 0U)))))
<< 0x34U) | (VL_ULL(0xfffffffffffff)
& (((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__isNaNOut)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN_io_in_b_isZero))
| VL_GTS_III(1,14,14, 0x3ceU, (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__sRoundedExp)))
?
((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__isNaNOut)
? VL_ULL(0x8000000000000)
: VL_ULL(0))
:
((1U
& (IData)(
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN_io_in_b_sig
>> 0x37U)))
?
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__roundedSig
>> 1U)
: vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__roundedSig))
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__pegMaxFiniteMagOut)
? VL_ULL(0xfffffffffffff)
: VL_ULL(0))))));
__Vtemp1943[1U] = (IData)(((((QData)((IData)((0xfffU
& (((((((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__sRoundedExp)
& (~
(((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN_io_in_b_isZero)
| VL_GTS_III(1,14,14, 0x3ceU, (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__sRoundedExp)))
? 0xe00U
: 0U)))
& (~
((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__pegMinNonzeroMagOut)
? 0xc31U
: 0U)))
& (~
((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__pegMaxFiniteMagOut)
? 0x400U
: 0U)))
& (~
((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__notNaN_isInfOut)
? 0x200U
: 0U)))
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__pegMinNonzeroMagOut)
? 0x3ceU
: 0U))
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__pegMaxFiniteMagOut)
? 0xbffU
: 0U))
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__notNaN_isInfOut)
? 0xc00U
: 0U))
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__isNaNOut)
? 0xe00U
: 0U)))))
<< 0x34U) | (VL_ULL(0xfffffffffffff)
& (((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__isNaNOut)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN_io_in_b_isZero))
| VL_GTS_III(1,14,14, 0x3ceU, (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__sRoundedExp)))
?
((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__isNaNOut)
? VL_ULL(0x8000000000000)
: VL_ULL(0))
:
((1U
& (IData)(
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN_io_in_b_sig
>> 0x37U)))
?
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__roundedSig
>> 1U)
: vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__roundedSig))
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__pegMaxFiniteMagOut)
? VL_ULL(0xfffffffffffff)
: VL_ULL(0)))))
>> 0x20U));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN_io_out[0U]
= __Vtemp1943[0U];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN_io_out[1U]
= __Vtemp1943[1U];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN_io_out[2U]
= ((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__isNaNOut))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN_io_in_b_sign));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__monitor__DOT___GEN_58
= ((5U == (7U & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__monitor__DOT___a_opcode_lookup_T_1
>> 1U))) ? 2U : ((4U == (7U
& (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__monitor__DOT___a_opcode_lookup_T_1
>> 1U)))
? 1U : (
(3U
==
(7U
& (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__monitor__DOT___a_opcode_lookup_T_1
>> 1U)))
? 1U
:
((2U
==
(7U
& (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__monitor__DOT___a_opcode_lookup_T_1
>> 1U)))
? 1U
: 0U))));
}
void VTestHarness::_settle__TOP__1037(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1037\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__monitor__DOT__same_cycle_resp
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__monitor__DOT___T_1257)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__monitor__DOT___same_cycle_resp_T_2));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__monitor__DOT__same_cycle_resp_1
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__monitor__DOT___T_1344)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__monitor__DOT___same_cycle_resp_T_8));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__monitor_io_in_d_bits_opcode
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT___T_144)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT___T_143));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__sink_ACancel_1_bits_opcode
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT___T_144)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT___T_143));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext_RW0_wmask
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT___GEN_58)
<< 0x10U) | (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT___GEN_59));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__dataArb_io_out_valid
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__dataArb__DOT___grant_T_1)
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcacheArb_io_mem_req_valid)
& (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT___dataArb_io_in_3_valid_res_T_2))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_e_q__DOT__do_enq
= ((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_e_q__DOT__full))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache_auto_out_e_valid));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache_auto_out_d_ready
= ((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT___T_294))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT___GEN_233));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT___T_271
= (((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT___T_294))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT___GEN_233))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__tlMasterXbar_auto_in_0_d_valid));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ll_wen
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT___T_117)
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__div_io_resp_ready)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__div_io_resp_valid)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__tlMasterXbar__DOT___readys_mask_T
= ((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__tlMasterXbar__DOT___readys_readys_T_2))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__tlMasterXbar__DOT__readys_filter_lo));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__tlMasterXbar__DOT__allowed_1
= (1U & ((0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__tlMasterXbar__DOT__beatsLeft))
? (~ ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__tlMasterXbar__DOT___readys_readys_T_2)
>> 1U)) : (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__tlMasterXbar__DOT__state_1)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__tlMasterXbar__DOT__earlyWinner_1
= ((~ ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__tlMasterXbar__DOT___readys_readys_T_2)
>> 1U)) & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__icache_auto_master_out_a_valid));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__tlMasterXbar__DOT__earlyWinner_0
= ((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__tlMasterXbar__DOT___readys_readys_T_2))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache_auto_out_a_valid));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__tlMasterXbar__DOT__allowed_0
= (1U & ((0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__tlMasterXbar__DOT__beatsLeft))
? (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__tlMasterXbar__DOT___readys_readys_T_2))
: (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__tlMasterXbar__DOT__state_0)));
}
void VTestHarness::_settle__TOP__1038(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1038\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT__monitor__DOT___T_423
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_out_0_a_bits_mask)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT__monitor__DOT__mask))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_cbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT__monitor__DOT___T_599
= ((0U == ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_out_0_a_bits_mask)
& (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT__monitor__DOT__mask))))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_cbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT__source_i_valid
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_out_0_a_valid)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT__a_allow));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__monitor__DOT__mask
= ((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__monitor__DOT__mask_acc_5)
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__monitor__DOT__mask_eq_5)
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__bundleOut_0_a_q_io_deq_bits_address))
<< 7U) | ((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__monitor__DOT__mask_acc_5)
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__monitor__DOT__mask_eq_5)
& (~ vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__bundleOut_0_a_q_io_deq_bits_address)))
<< 6U) | ((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__monitor__DOT__mask_acc_4)
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__monitor__DOT__mask_eq_4)
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__bundleOut_0_a_q_io_deq_bits_address))
<< 5U) | ((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__monitor__DOT__mask_acc_4)
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__monitor__DOT__mask_eq_4)
& (~ vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__bundleOut_0_a_q_io_deq_bits_address)))
<< 4U)
| ((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__monitor__DOT__mask_acc_3)
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__monitor__DOT__mask_eq_3)
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__bundleOut_0_a_q_io_deq_bits_address))
<< 3U)
| ((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__monitor__DOT__mask_acc_3)
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__monitor__DOT__mask_eq_3)
& (~ vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__bundleOut_0_a_q_io_deq_bits_address)))
<< 2U)
| ((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__monitor__DOT__mask_acc_2)
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__monitor__DOT__mask_eq_2)
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__bundleOut_0_a_q_io_deq_bits_address))
<< 1U)
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__monitor__DOT__mask_acc_2)
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__monitor__DOT__mask_eq_2)
& (~ vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__bundleOut_0_a_q_io_deq_bits_address))))))))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__request_bits_offset
= (0x3fU & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC_io_req_valid)
? vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__offset
: (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT___request_bits_T_offset)));
}
void VTestHarness::_settle__TOP__1039(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1039\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__request_bits_tag
= (0x1fffU & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC_io_req_valid)
? (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__offset
>> 0x10U) : (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT___request_bits_T_tag)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__setMatches
= ((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__request_valid)
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__request_set)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__request_bits_set)))
<< 6U) | ((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__request_valid)
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__request_set)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__request_bits_set)))
<< 5U) | ((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__request_valid)
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__request_set)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__request_bits_set)))
<< 4U) | ((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__request_valid)
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__request_set)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__request_bits_set)))
<< 3U)
| ((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__request_valid)
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__request_set)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__request_bits_set)))
<< 2U)
| ((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__request_valid)
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__request_set)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__request_bits_set)))
<< 1U)
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__request_valid)
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__request_set)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__request_bits_set)))))))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__queue_arw_deq__DOT___GEN_18
= ((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__queue_arw_deq_io_deq_ready))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__queue_arw_deq__DOT___do_enq_T));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__subsystem_mbus_xbar__DOT__monitor__DOT___T_625
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__subsystem_mbus_xbar__DOT__monitor__DOT___a_first_T)
& (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__subsystem_mbus_xbar__DOT__monitor__DOT__a_first_counter)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__subsystem_mbus_xbar__DOT__monitor__DOT___T_657
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__subsystem_mbus_xbar__DOT__monitor__DOT___a_first_T)
& (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__subsystem_mbus_xbar__DOT__monitor__DOT__a_first_counter_1)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__fixer__DOT__monitor__DOT___T_625
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__fixer__DOT__monitor__DOT___a_first_T)
& (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__fixer__DOT__monitor__DOT__a_first_counter)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__fixer__DOT__monitor__DOT___T_657
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__fixer__DOT__monitor__DOT___a_first_T)
& (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__fixer__DOT__monitor__DOT__a_first_counter_1)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__binder__DOT__monitor__DOT___T_625
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__binder__DOT__monitor__DOT___a_first_T)
& (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__binder__DOT__monitor__DOT__a_first_counter)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__binder__DOT__monitor__DOT___T_657
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__binder__DOT__monitor__DOT___a_first_T)
& (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__binder__DOT__monitor__DOT__a_first_counter_1)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork_auto_in_c_ready
= (1U & ((6U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceC__DOT__queue__DOT__ram_opcode_io_deq_bits_MPORT_data))
? (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__q__DOT__full))
: (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__out_ready)));
}
void VTestHarness::_settle__TOP__1040(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1040\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Variables
// Begin mtask footprint all:
WData/*95:0*/ __Vtemp1945[3];
WData/*95:0*/ __Vtemp1946[3];
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__monitor_io_in_c_ready
= (1U & ((6U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceC__DOT__queue__DOT__ram_opcode_io_deq_bits_MPORT_data))
? (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__q__DOT__full))
: (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__out_ready)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceA__DOT__io_a_q__DOT__do_deq
= (1U & (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__toD)
? (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__q_1__DOT__full))
: (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__out_1_ready))
& (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceA__DOT__io_a_q__DOT__empty))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__monitor_io_in_a_ready
= (1U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__toD)
? (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__q_1__DOT__full))
: (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__out_1_ready)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__deq__DOT___T
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__deq__DOT__maybe_full)
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__deq__DOT___do_enq_T)
: (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__deq__DOT___GEN_9))
!= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__deq__DOT__maybe_full)
& ((IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fw_ready_reg)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__deq_io_deq_valid))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT___T_62
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4_auto_out_aw_valid)
& (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Faw_ready_reg));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT___T_8
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4_auto_out_ar_valid)
& (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Far_ready_reg));
__Vtemp1945[0U] = (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__alu__DOT__shin);
__Vtemp1945[1U] = (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__alu__DOT__shin
>> 0x20U));
__Vtemp1945[2U] = (1U & (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ex_ctrl_alu_fn)
>> 3U) & (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__alu__DOT__shin
>> 0x3fU))));
VL_SHIFTRS_WWI(65,65,6, __Vtemp1946, __Vtemp1945,
((((IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__alu_io_in2
>> 5U)) & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ex_ctrl_alu_dw))
<< 5U) | (0x1fU & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__alu_io_in2))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__alu__DOT___shout_r_T_4[0U]
= __Vtemp1946[0U];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__alu__DOT___shout_r_T_4[1U]
= __Vtemp1946[1U];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__alu__DOT___shout_r_T_4[2U]
= (1U & __Vtemp1946[2U]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT___T_58
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT___io_schedule_bits_c_valid_T_1)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT___T_93
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT___io_schedule_bits_dir_valid_T_3)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT___T_58
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT___io_schedule_bits_c_valid_T_1)
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH)
>> 1U));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT___T_93
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT___io_schedule_bits_dir_valid_T_3)
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH)
>> 1U));
}
void VTestHarness::_settle__TOP__1041(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1041\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT___T_58
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT___io_schedule_bits_c_valid_T_1)
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH)
>> 2U));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT___T_93
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT___io_schedule_bits_dir_valid_T_3)
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH)
>> 2U));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT___T_58
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT___io_schedule_bits_c_valid_T_1)
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH)
>> 3U));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT___T_93
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT___io_schedule_bits_dir_valid_T_3)
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH)
>> 3U));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT___T_58
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT___io_schedule_bits_c_valid_T_1)
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH)
>> 4U));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT___T_93
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT___io_schedule_bits_dir_valid_T_3)
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH)
>> 4U));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT___T_58
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT___io_schedule_bits_c_valid_T_1)
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH)
>> 5U));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT___T_93
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT___io_schedule_bits_dir_valid_T_3)
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH)
>> 5U));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT___T_58
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT___io_schedule_bits_c_valid_T_1)
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH)
>> 6U));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT___T_93
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT___io_schedule_bits_dir_valid_T_3)
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH)
>> 6U));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceC_io_req_bits_param
= ((((((((1U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH))
? ((1U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__meta_state))
? 2U : 1U) : 0U) | ((2U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH))
? ((1U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__meta_state))
? 2U
: 1U)
: 0U)) |
((4U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH))
? ((1U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__meta_state))
? 2U : 1U) : 0U)) | ((8U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH))
? ((1U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__meta_state))
? 2U
: 1U)
: 0U)) |
((0x10U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH))
? ((1U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__meta_state))
? 2U : 1U) : 0U)) | ((0x20U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH))
? ((1U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__meta_state))
? 2U : 1U)
: 0U)) | (
(0x40U
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH))
?
((1U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__meta_state))
? 2U
: 1U)
: 0U));
}
void VTestHarness::_settle__TOP__1042(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1042\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceC_io_req_bits_tag
= ((((((((1U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__meta_tag)
: 0U) | ((2U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__meta_tag)
: 0U)) | ((4U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__meta_tag)
: 0U)) | ((8U
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__meta_tag)
: 0U))
| ((0x10U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__meta_tag)
: 0U)) | ((0x20U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__meta_tag)
: 0U)) | ((0x40U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__meta_tag)
: 0U));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD_io_req_bits_prio_2
= ((((((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__request_prio_2))
| (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH)
>> 1U) & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__request_prio_2)))
| (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH)
>> 2U) & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__request_prio_2)))
| (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH)
>> 3U) & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__request_prio_2)))
| (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH)
>> 4U) & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__request_prio_2)))
| (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH)
>> 5U) & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__request_prio_2)))
| (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH)
>> 6U) & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__request_prio_2)));
}
void VTestHarness::_settle__TOP__1043(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1043\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD_io_req_bits_source
= ((((((((1U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__request_source)
: 0U) | ((2U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__request_source)
: 0U)) | ((4U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__request_source)
: 0U)) | ((8U
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__request_source)
: 0U))
| ((0x10U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__request_source)
: 0U)) | ((0x20U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__request_source)
: 0U)) | ((0x40U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__request_source)
: 0U));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD_io_req_bits_put
= ((((((((1U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__request_put)
: 0U) | ((2U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__request_put)
: 0U)) | ((4U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__request_put)
: 0U)) | ((8U
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__request_put)
: 0U))
| ((0x10U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__request_put)
: 0U)) | ((0x20U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__request_put)
: 0U)) | ((0x40U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__request_put)
: 0U));
}
void VTestHarness::_settle__TOP__1044(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1044\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD_io_req_bits_bad
= ((((((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__bad_grant))
| (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH)
>> 1U) & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__bad_grant)))
| (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH)
>> 2U) & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__bad_grant)))
| (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH)
>> 3U) & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__bad_grant)))
| (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH)
>> 4U) & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__bad_grant)))
| (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH)
>> 5U) & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__bad_grant)))
| (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH)
>> 6U) & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__bad_grant)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT___robin_filter_T_1
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH)
| (0x3fU & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH)
>> 1U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceA__DOT__a_bits_address_base
= ((((((((((1U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__request_tag)
: 0U) | ((2U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__request_tag)
: 0U)) | ((4U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__request_tag)
: 0U)) | (
(8U
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__request_tag)
: 0U))
| ((0x10U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__request_tag)
: 0U)) | ((0x20U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__request_tag)
: 0U)) | ((0x40U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__request_tag)
: 0U)) << 0x10U)
| (((((((((1U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__request_set)
: 0U) | ((2U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__request_set)
: 0U)) | ((4U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__request_set)
: 0U)) |
((8U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__request_set)
: 0U)) | ((0x10U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__request_set)
: 0U)) | ((0x20U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__request_set)
: 0U)) |
((0x40U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__request_set)
: 0U)) << 6U));
}
void VTestHarness::_settle__TOP__1057(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1057\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__schedule_reload
= ((((((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0_io_schedule_bits_reload))
| (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH)
>> 1U) & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1_io_schedule_bits_reload)))
| (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH)
>> 2U) & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2_io_schedule_bits_reload)))
| (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH)
>> 3U) & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3_io_schedule_bits_reload)))
| (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH)
>> 4U) & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4_io_schedule_bits_reload)))
| (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH)
>> 5U) & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr_io_schedule_bits_reload)))
| (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH)
>> 6U) & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr_io_schedule_bits_reload)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__selected_requests
= ((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH)
<< 0xeU) | (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH)
<< 7U) | (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH)))
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__valid);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT___pop_index_T_1
= (0x1fffffU & ((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH)
<< 0xeU) | (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH)
<< 7U) | (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__mshr_selectOH)))
& (~ (((~ vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__valid)
| (0x3fffU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__valid
>> 7U)))
| (0x7fU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__valid
>> 0xeU))))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__csr__DOT___io_decode_0_read_illegal_T_310
= (1U & ((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__csr__DOT___io_decode_0_read_illegal_T_1)
| (~ (((((((((((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__csr__DOT___io_decode_0_read_illegal_T_282)
| (0x3b8U == (0xfffU
& (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ibuf_io_inst_0_bits_raw
>> 0x14U))))
| (0x3b9U == (0xfffU
& (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ibuf_io_inst_0_bits_raw
>> 0x14U))))
| (0x3baU == (0xfffU
& (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ibuf_io_inst_0_bits_raw
>> 0x14U))))
| (0x3bbU == (0xfffU
& (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ibuf_io_inst_0_bits_raw
>> 0x14U))))
| (0x3bcU == (0xfffU
& (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ibuf_io_inst_0_bits_raw
>> 0x14U))))
| (0x3bdU == (0xfffU
& (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ibuf_io_inst_0_bits_raw
>> 0x14U))))
| (0x3beU == (0xfffU
& (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ibuf_io_inst_0_bits_raw
>> 0x14U))))
| (0x3bfU == (0xfffU &
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ibuf_io_inst_0_bits_raw
>> 0x14U))))
| (0x7c1U == (0xfffU &
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ibuf_io_inst_0_bits_raw
>> 0x14U))))
| (0xf12U == (0xfffU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ibuf_io_inst_0_bits_raw
>> 0x14U))))
| (0xf11U == (0xfffU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ibuf_io_inst_0_bits_raw
>> 0x14U))))
| (0xf13U == (0xfffU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ibuf_io_inst_0_bits_raw
>> 0x14U))))))
| ((0x180U == (0xfffU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ibuf_io_inst_0_bits_raw
>> 0x14U)))
& (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__csr__DOT__allow_sfence_vma))))
| ((((0xc00U <= (0xfffU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ibuf_io_inst_0_bits_raw
>> 0x14U)))
& (0xc20U > (0xfffU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ibuf_io_inst_0_bits_raw
>> 0x14U))))
| ((0xc80U <= (0xfffU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ibuf_io_inst_0_bits_raw
>> 0x14U)))
& (0xca0U > (0xfffU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ibuf_io_inst_0_bits_raw
>> 0x14U)))))
& (~ (((1U < (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__csr__DOT__reg_mstatus_prv))
| ((7U & vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__csr__DOT__reg_mcounteren)
>> (0x1fU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ibuf_io_inst_0_bits_raw
>> 0x14U))))
& ((1U <= (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__csr__DOT__reg_mstatus_prv))
| ((7U & vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__csr__DOT__reg_scounteren)
>> (0x1fU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ibuf_io_inst_0_bits_raw
>> 0x14U)))))))));
}
void VTestHarness::_settle__TOP__1063(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1063\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Variables
// Begin mtask footprint all:
WData/*95:0*/ __Vtemp1952[3];
WData/*95:0*/ __Vtemp1954[3];
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar__DOT___readys_mask_T
= ((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar__DOT___readys_readys_T_2))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar__DOT__readys_filter_lo));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar__DOT__earlyWinner_1
= ((~ ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar__DOT___readys_readys_T_2)
>> 1U)) & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar_auto_out_1_a_valid));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar__DOT__earlyWinner_0
= ((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar__DOT___readys_readys_T_2))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiBypass__DOT__bar_auto_in_d_valid));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar__DOT__latch
= ((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar__DOT__beatsLeft))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__dtm_io_dmi_resp_ready));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar__DOT___beatsLeft_T_4
= (1U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar__DOT__beatsLeft)
- ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__dtm_io_dmi_resp_ready)
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar__DOT__beatsLeft)
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar__DOT___sink_ACancel_earlyValid_T_3)
: (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar__DOT___T_10)))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar__DOT__monitor__DOT__d_first_done
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__dtm_io_dmi_resp_ready)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar__DOT__monitor_io_in_d_valid));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar_auto_out_1_d_ready
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__dtm_io_dmi_resp_ready)
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar__DOT__beatsLeft)
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar__DOT__state_1)
: (~ ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar__DOT___readys_readys_T_2)
>> 1U))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar_auto_out_0_d_ready
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__dtm_io_dmi_resp_ready)
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar__DOT__beatsLeft)
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar__DOT__state_0)
: (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar__DOT___readys_readys_T_2))));
VL_EXTEND_WQ(65,33, __Vtemp1952, (((QData)((IData)(
((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__isNaNOut))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt__DOT__divSqrtRecFNToRaw__DOT__divSqrtRawFN___DOT__sign_Z))))
<< 0x20U) | (QData)((IData)(
((0xff800000U
& ((((((((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__sRoundedExp)
& (~
(((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt__DOT__divSqrtRecFNToRaw__DOT__divSqrtRawFN___DOT__isZero_Z)
| VL_GTS_III(1,11,11, 0x6bU, (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__sRoundedExp)))
? 0x1c0U
: 0U)))
& (~
((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__pegMinNonzeroMagOut)
? 0x194U
: 0U)))
& (~
((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__pegMaxFiniteMagOut)
? 0x80U
: 0U)))
& (~
((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__notNaN_isInfOut)
? 0x40U
: 0U)))
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__pegMinNonzeroMagOut)
? 0x6bU
: 0U))
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__pegMaxFiniteMagOut)
? 0x17fU
: 0U))
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__notNaN_isInfOut)
? 0x180U
: 0U))
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__isNaNOut)
? 0x1c0U
: 0U))
<< 0x17U))
| (0x7fffffU
& (((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__isNaNOut)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt__DOT__divSqrtRecFNToRaw__DOT__divSqrtRawFN___DOT__isZero_Z))
| VL_GTS_III(1,11,11, 0x6bU, (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__sRoundedExp)))
?
((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__isNaNOut)
? 0x400000U
: 0U)
:
((0x4000000U
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt__DOT__divSqrtRecFNToRaw__DOT__divSqrtRawFN___05Fio_rawOut_sig)
?
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__roundedSig
>> 1U)
: vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__roundedSig))
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__pegMaxFiniteMagOut)
? 0x7fffffU
: 0U))))))));
VL_EXTEND_WQ(65,33, __Vtemp1954, (((QData)((IData)(
((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__isNaNOut))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__fma__DOT__roundRawFNToRecFN_io_in_b_sign))))
<< 0x20U) | (QData)((IData)(
((0xff800000U
& ((((((((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__sRoundedExp)
& (~
(((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__fma__DOT__roundRawFNToRecFN_io_in_b_isZero)
| VL_GTS_III(1,11,11, 0x6bU, (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__sRoundedExp)))
? 0x1c0U
: 0U)))
& (~
((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__pegMinNonzeroMagOut)
? 0x194U
: 0U)))
& (~
((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__pegMaxFiniteMagOut)
? 0x80U
: 0U)))
& (~
((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__notNaN_isInfOut)
? 0x40U
: 0U)))
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__pegMinNonzeroMagOut)
? 0x6bU
: 0U))
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__pegMaxFiniteMagOut)
? 0x17fU
: 0U))
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__notNaN_isInfOut)
? 0x180U
: 0U))
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__isNaNOut)
? 0x1c0U
: 0U))
<< 0x17U))
| (0x7fffffU
& (((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__isNaNOut)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__fma__DOT__roundRawFNToRecFN_io_in_b_isZero))
| VL_GTS_III(1,11,11, 0x6bU, (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__sRoundedExp)))
?
((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__isNaNOut)
? 0x400000U
: 0U)
:
((0x4000000U
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__fma__DOT__roundRawFNToRecFN_io_in_b_sig)
?
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__roundedSig
>> 1U)
: vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__roundedSig))
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__pegMaxFiniteMagOut)
? 0x7fffffU
: 0U))))))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT___wdata_T_19[0U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_wen)
? ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_typeTag)
? ((7U == (7U & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN_io_out[2U]
<< 3U) | (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN_io_out[1U]
>> 0x1dU))))
? vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN_io_out[0U]
: vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN_io_out[0U])
: __Vtemp1952[0U]) : ((3U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__wbInfo_0_pipeid))
? vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__io_out_b_data[0U]
: ((2U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__wbInfo_0_pipeid))
? __Vtemp1954[0U]
: ((1U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__wbInfo_0_pipeid))
? vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__ifpu__DOT__io_out_b_data[0U]
: vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpmu__DOT__io_out_b_data[0U]))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT___wdata_T_19[1U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_wen)
? ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_typeTag)
? ((7U == (7U & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN_io_out[2U]
<< 3U) | (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN_io_out[1U]
>> 0x1dU))))
? (0xefefffffU & vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN_io_out[1U])
: vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN_io_out[1U])
: __Vtemp1952[1U]) : ((3U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__wbInfo_0_pipeid))
? vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__io_out_b_data[1U]
: ((2U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__wbInfo_0_pipeid))
? __Vtemp1954[1U]
: ((1U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__wbInfo_0_pipeid))
? vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__ifpu__DOT__io_out_b_data[1U]
: vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpmu__DOT__io_out_b_data[1U]))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT___wdata_T_19[2U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_wen)
? ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_typeTag)
? ((7U == (7U & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN_io_out[2U]
<< 3U) | (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN_io_out[1U]
>> 0x1dU))))
? (1U & vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN_io_out[2U])
: vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN_io_out[2U])
: __Vtemp1952[2U]) : ((3U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__wbInfo_0_pipeid))
? vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__io_out_b_data[2U]
: ((2U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__wbInfo_0_pipeid))
? __Vtemp1954[2U]
: ((1U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__wbInfo_0_pipeid))
? vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__ifpu__DOT__io_out_b_data[2U]
: vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpmu__DOT__io_out_b_data[2U]))));
}
void VTestHarness::_settle__TOP__1064(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1064\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor__DOT___T_1143
= (1U & ((((1U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor__DOT___GEN_15))
!= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor__DOT___T_1088)
? 1U : 0U)) | (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor__DOT___GEN_15)))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor__DOT___T_1143
= (1U & ((((1U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor__DOT___GEN_15))
!= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor__DOT___T_1088)
? 1U : 0U)) | (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor__DOT___GEN_15)))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___T_2275
= (1U & (((7U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT__inflight)
>> (3U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__sink_ACancel_7_bits_source))))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT__same_cycle_resp))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___T_2361
= (1U & (((7U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT__inflight_1)
>> (3U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__sink_ACancel_7_bits_source))))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT__same_cycle_resp_1))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___T_2275
= (1U & (((7U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT__inflight)
>> (3U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__sink_ACancel_7_bits_source))))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT__same_cycle_resp))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___T_2361
= (1U & (((7U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT__inflight_1)
>> (3U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__sink_ACancel_7_bits_source))))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT__same_cycle_resp_1))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset)));
}
void VTestHarness::_settle__TOP__1065(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1065\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___T_2293
= ((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1_io_in_d_bits_opcode)
== ((7U == (7U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___a_opcode_lookup_T_1)
>> 1U))) ? 4U : ((6U
==
(7U
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___a_opcode_lookup_T_1)
>> 1U)))
? 4U
: (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___GEN_58))))
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1_io_in_d_bits_opcode)
== ((7U == (7U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___a_opcode_lookup_T_1)
>> 1U))) ? 4U : ((6U
==
(7U
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___a_opcode_lookup_T_1)
>> 1U)))
? 5U
: (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___GEN_58)))))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___T_2293
= ((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_in_1_d_bits_opcode)
== ((7U == (7U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___a_opcode_lookup_T_1)
>> 1U))) ? 4U : ((6U
==
(7U
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___a_opcode_lookup_T_1)
>> 1U)))
? 4U
: (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___GEN_58))))
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar_auto_in_1_d_bits_opcode)
== ((7U == (7U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___a_opcode_lookup_T_1)
>> 1U))) ? 4U : ((6U
==
(7U
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___a_opcode_lookup_T_1)
>> 1U)))
? 5U
: (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___GEN_58)))))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset));
}
void VTestHarness::_settle__TOP__1066(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1066\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___T_2316
= (1U & ((((7U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___GEN_27))
!= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___T_2261)
? (7U & ((IData)(1U) << (3U
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__sink_ACancel_7_bits_source))))
: 0U)) | (~ (IData)((0U !=
(7U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___GEN_27))))))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___T_2385
= ((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___T_2334)
? (7U & ((IData)(1U) << (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_c_q__DOT__ram_source_io_deq_bits_MPORT_data)))
: 0U) != ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___T_2349)
? (7U & ((IData)(1U) << (3U
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__sink_ACancel_7_bits_source))))
: 0U)) | (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___inflight_T_8
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT__inflight_2)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT__d_set))
& (~ ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_e_q__DOT__empty)
? 0U : ((IData)(1U) << (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_e_q__DOT__ram_sink_io_deq_bits_MPORT_data)))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___T_2419
= (1U & ((0xffU & (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT__d_set)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT__inflight_2))
>> (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_e_q__DOT__ram_sink_io_deq_bits_MPORT_data)))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___inflight_T_5
= (7U & (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT__inflight_1)
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___T_2340)
? (0xfU & ((IData)(1U) << (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_c_q__DOT__ram_source_io_deq_bits_MPORT_data)))
: 0U)) & (~ ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___T_2353)
? (0xfU & ((IData)(1U)
<< (3U
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__sink_ACancel_7_bits_source))))
: 0U))));
}
void VTestHarness::_settle__TOP__1067(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1067\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___inflight_sizes_T_5
= (0xffffffU & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT__inflight_sizes_1
| (IData)(((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___T_2340)
? (VL_ULL(0xfffffffff)
& ((QData)((IData)(
((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___T_2340)
?
(1U
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_c_q__DOT__ram_size_io_deq_bits_MPORT_data)
<< 1U))
: 0U)))
<< ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_c_q__DOT__ram_source_io_deq_bits_MPORT_data)
<< 3U)))
: VL_ULL(0))))
& (~ (IData)(((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__fixer__DOT__monitor_1__DOT___T_2353)
? (VL_ULL(0x7fffffffffff)
& (VL_ULL(0xff)
<< (0x18U
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__sink_ACancel_7_bits_source)
<< 3U))))
: VL_ULL(0))))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___T_2316
= (1U & ((((7U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___GEN_27))
!= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___T_2261)
? (7U & ((IData)(1U) << (3U
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__sink_ACancel_7_bits_source))))
: 0U)) | (~ (IData)((0U !=
(7U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___GEN_27))))))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___T_2385
= ((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___T_2334)
? (7U & ((IData)(1U) << (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_c_q__DOT__ram_source_io_deq_bits_MPORT_data)))
: 0U) != ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___T_2349)
? (7U & ((IData)(1U) << (3U
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__sink_ACancel_7_bits_source))))
: 0U)) | (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___inflight_T_8
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT__inflight_2)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT__d_set))
& (~ ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_e_q__DOT__empty)
? 0U : ((IData)(1U) << (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_e_q__DOT__ram_sink_io_deq_bits_MPORT_data)))));
}
void VTestHarness::_settle__TOP__1068(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1068\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Variables
// Begin mtask footprint all:
WData/*95:0*/ __Vtemp1963[3];
WData/*95:0*/ __Vtemp1964[3];
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___T_2419
= (1U & ((0xffU & (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT__d_set)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT__inflight_2))
>> (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_e_q__DOT__ram_sink_io_deq_bits_MPORT_data)))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_sbus_0_reset_catcher_io_sync_reset)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___inflight_T_5
= (7U & (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT__inflight_1)
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___T_2340)
? (0xfU & ((IData)(1U) << (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_c_q__DOT__ram_source_io_deq_bits_MPORT_data)))
: 0U)) & (~ ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___T_2353)
? (0xfU & ((IData)(1U)
<< (3U
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__sink_ACancel_7_bits_source))))
: 0U))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___inflight_sizes_T_5
= (0xffffffU & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT__inflight_sizes_1
| (IData)(((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___T_2340)
? (VL_ULL(0xfffffffff)
& ((QData)((IData)(
((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___T_2340)
?
(1U
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_c_q__DOT__ram_size_io_deq_bits_MPORT_data)
<< 1U))
: 0U)))
<< ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_c_q__DOT__ram_source_io_deq_bits_MPORT_data)
<< 3U)))
: VL_ULL(0))))
& (~ (IData)(((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__monitor_1__DOT___T_2353)
? (VL_ULL(0x7fffffffffff)
& (VL_ULL(0xff)
<< (0x18U
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT__sink_ACancel_7_bits_source)
<< 3U))))
: VL_ULL(0))))));
VL_EXTEND_WI(67,4, __Vtemp1963, ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__fragmenter__DOT__monitor__DOT___T_651)
? (1U | ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_opcode_io_deq_bits_MPORT_data)
<< 1U))
: 0U));
VL_SHIFTL_WWI(67,67,6, __Vtemp1964, __Vtemp1963,
((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_source_io_deq_bits_MPORT_data)
<< 2U));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__fragmenter__DOT__monitor__DOT___inflight_opcodes_T_2
= (0xfffffU & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__fragmenter__DOT__monitor__DOT__inflight_opcodes
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__fragmenter__DOT__monitor__DOT___T_651)
? __Vtemp1964[0U] : 0U))
& (~ vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__fragmenter__DOT__monitor__DOT___GEN_23[0U])));
}
void VTestHarness::_settle__TOP__1069(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1069\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Variables
// Begin mtask footprint all:
WData/*95:0*/ __Vtemp1969[3];
WData/*95:0*/ __Vtemp1970[3];
WData/*127:0*/ __Vtemp1974[4];
WData/*127:0*/ __Vtemp1975[4];
WData/*1055:0*/ __Vtemp1982[33];
WData/*1055:0*/ __Vtemp1983[33];
WData/*127:0*/ __Vtemp1991[4];
WData/*127:0*/ __Vtemp1992[4];
WData/*127:0*/ __Vtemp1997[4];
WData/*127:0*/ __Vtemp1998[4];
WData/*1055:0*/ __Vtemp2006[33];
WData/*1055:0*/ __Vtemp2007[33];
WData/*127:0*/ __Vtemp2012[4];
WData/*127:0*/ __Vtemp2013[4];
WData/*127:0*/ __Vtemp2018[4];
WData/*127:0*/ __Vtemp2019[4];
// Body
VL_EXTEND_WI(67,4, __Vtemp1969, ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__fragmenter__DOT__monitor__DOT___T_651)
? (1U | ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_size_io_deq_bits_MPORT_data)
<< 1U))
: 0U));
VL_SHIFTL_WWI(67,67,6, __Vtemp1970, __Vtemp1969,
((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_source_io_deq_bits_MPORT_data)
<< 2U));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__fragmenter__DOT__monitor__DOT___inflight_sizes_T_2
= (0xfffffU & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__fragmenter__DOT__monitor__DOT__inflight_sizes
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__fragmenter__DOT__monitor__DOT___T_651)
? __Vtemp1970[0U] : 0U))
& (~ vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__fragmenter__DOT__monitor__DOT___GEN_23[0U])));
__Vtemp1974[0U] = 1U;
__Vtemp1974[1U] = 0U;
__Vtemp1974[2U] = 0U;
__Vtemp1974[3U] = 0U;
VL_SHIFTL_WWI(128,128,7, __Vtemp1975, __Vtemp1974, (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_source_io_deq_bits_MPORT_data));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___inflight_T_5[0U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT__inflight_1[0U]
& (~ ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_700)
? __Vtemp1975[0U] : 0U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___inflight_T_5[1U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT__inflight_1[1U]
& (~ ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_700)
? __Vtemp1975[1U] : 0U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___inflight_T_5[2U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT__inflight_1[2U]
& (~ ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_700)
? __Vtemp1975[2U] : 0U)));
__Vtemp1982[0U] = 0xfU;
__Vtemp1982[1U] = 0U;
__Vtemp1982[2U] = 0U;
__Vtemp1982[3U] = 0U;
__Vtemp1982[4U] = 0U;
__Vtemp1982[5U] = 0U;
__Vtemp1982[6U] = 0U;
__Vtemp1982[7U] = 0U;
__Vtemp1982[8U] = 0U;
__Vtemp1982[9U] = 0U;
__Vtemp1982[0xaU] = 0U;
__Vtemp1982[0xbU] = 0U;
__Vtemp1982[0xcU] = 0U;
__Vtemp1982[0xdU] = 0U;
__Vtemp1982[0xeU] = 0U;
__Vtemp1982[0xfU] = 0U;
__Vtemp1982[0x10U] = 0U;
__Vtemp1982[0x11U] = 0U;
__Vtemp1982[0x12U] = 0U;
__Vtemp1982[0x13U] = 0U;
__Vtemp1982[0x14U] = 0U;
__Vtemp1982[0x15U] = 0U;
__Vtemp1982[0x16U] = 0U;
__Vtemp1982[0x17U] = 0U;
__Vtemp1982[0x18U] = 0U;
__Vtemp1982[0x19U] = 0U;
__Vtemp1982[0x1aU] = 0U;
__Vtemp1982[0x1bU] = 0U;
__Vtemp1982[0x1cU] = 0U;
__Vtemp1982[0x1dU] = 0U;
__Vtemp1982[0x1eU] = 0U;
__Vtemp1982[0x1fU] = 0U;
__Vtemp1982[0x20U] = 0U;
VL_SHIFTL_WWI(1039,1039,10, __Vtemp1983, __Vtemp1982,
((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_source_io_deq_bits_MPORT_data)
<< 2U));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___inflight_sizes_T_5[0U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT__inflight_sizes_1[0U]
& (~ ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_700)
? __Vtemp1983[0U] : 0U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___inflight_sizes_T_5[1U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT__inflight_sizes_1[1U]
& (~ ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_700)
? __Vtemp1983[1U] : 0U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___inflight_sizes_T_5[2U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT__inflight_sizes_1[2U]
& (~ ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_700)
? __Vtemp1983[2U] : 0U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___inflight_sizes_T_5[3U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT__inflight_sizes_1[3U]
& (~ ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_700)
? __Vtemp1983[3U] : 0U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___inflight_sizes_T_5[4U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT__inflight_sizes_1[4U]
& (~ ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_700)
? __Vtemp1983[4U] : 0U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___inflight_sizes_T_5[5U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT__inflight_sizes_1[5U]
& (~ ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_700)
? __Vtemp1983[5U] : 0U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___inflight_sizes_T_5[6U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT__inflight_sizes_1[6U]
& (~ ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_700)
? __Vtemp1983[6U] : 0U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___inflight_sizes_T_5[7U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT__inflight_sizes_1[7U]
& (~ ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_700)
? __Vtemp1983[7U] : 0U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___inflight_sizes_T_5[8U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT__inflight_sizes_1[8U]
& (~ ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_700)
? __Vtemp1983[8U] : 0U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___inflight_sizes_T_5[9U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT__inflight_sizes_1[9U]
& (~ ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_700)
? __Vtemp1983[9U] : 0U)));
__Vtemp1991[0U] = 1U;
__Vtemp1991[1U] = 0U;
__Vtemp1991[2U] = 0U;
__Vtemp1991[3U] = 0U;
VL_SHIFTL_WWI(128,128,7, __Vtemp1992, __Vtemp1991, (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__fragmenter_auto_out_a_bits_source));
__Vtemp1997[0U] = 1U;
__Vtemp1997[1U] = 0U;
__Vtemp1997[2U] = 0U;
__Vtemp1997[3U] = 0U;
VL_SHIFTL_WWI(128,128,7, __Vtemp1998, __Vtemp1997, (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_source_io_deq_bits_MPORT_data));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___inflight_T_2[0U]
= ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT__inflight[0U]
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_597)
? __Vtemp1992[0U] : 0U)) & (~ ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_613)
? __Vtemp1998[0U]
: 0U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___inflight_T_2[1U]
= ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT__inflight[1U]
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_597)
? __Vtemp1992[1U] : 0U)) & (~ ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_613)
? __Vtemp1998[1U]
: 0U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___inflight_T_2[2U]
= (0xffffU & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT__inflight[2U]
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_597)
? __Vtemp1992[2U] : 0U))
& (~ ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_613)
? __Vtemp1998[2U] : 0U))));
__Vtemp2006[0U] = 0xfU;
__Vtemp2006[1U] = 0U;
__Vtemp2006[2U] = 0U;
__Vtemp2006[3U] = 0U;
__Vtemp2006[4U] = 0U;
__Vtemp2006[5U] = 0U;
__Vtemp2006[6U] = 0U;
__Vtemp2006[7U] = 0U;
__Vtemp2006[8U] = 0U;
__Vtemp2006[9U] = 0U;
__Vtemp2006[0xaU] = 0U;
__Vtemp2006[0xbU] = 0U;
__Vtemp2006[0xcU] = 0U;
__Vtemp2006[0xdU] = 0U;
__Vtemp2006[0xeU] = 0U;
__Vtemp2006[0xfU] = 0U;
__Vtemp2006[0x10U] = 0U;
__Vtemp2006[0x11U] = 0U;
__Vtemp2006[0x12U] = 0U;
__Vtemp2006[0x13U] = 0U;
__Vtemp2006[0x14U] = 0U;
__Vtemp2006[0x15U] = 0U;
__Vtemp2006[0x16U] = 0U;
__Vtemp2006[0x17U] = 0U;
__Vtemp2006[0x18U] = 0U;
__Vtemp2006[0x19U] = 0U;
__Vtemp2006[0x1aU] = 0U;
__Vtemp2006[0x1bU] = 0U;
__Vtemp2006[0x1cU] = 0U;
__Vtemp2006[0x1dU] = 0U;
__Vtemp2006[0x1eU] = 0U;
__Vtemp2006[0x1fU] = 0U;
__Vtemp2006[0x20U] = 0U;
VL_SHIFTL_WWI(1039,1039,10, __Vtemp2007, __Vtemp2006,
((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_source_io_deq_bits_MPORT_data)
<< 2U));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___GEN_23[0U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_613)
? __Vtemp2007[0U] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___GEN_23[1U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_613)
? __Vtemp2007[1U] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___GEN_23[2U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_613)
? __Vtemp2007[2U] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___GEN_23[3U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_613)
? __Vtemp2007[3U] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___GEN_23[4U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_613)
? __Vtemp2007[4U] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___GEN_23[5U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_613)
? __Vtemp2007[5U] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___GEN_23[6U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_613)
? __Vtemp2007[6U] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___GEN_23[7U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_613)
? __Vtemp2007[7U] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___GEN_23[8U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_613)
? __Vtemp2007[8U] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___GEN_23[9U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_613)
? __Vtemp2007[9U] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___GEN_23[0xaU]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_613)
? __Vtemp2007[0xaU] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___GEN_23[0xbU]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_613)
? __Vtemp2007[0xbU] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___GEN_23[0xcU]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_613)
? __Vtemp2007[0xcU] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___GEN_23[0xdU]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_613)
? __Vtemp2007[0xdU] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___GEN_23[0xeU]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_613)
? __Vtemp2007[0xeU] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___GEN_23[0xfU]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_613)
? __Vtemp2007[0xfU] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___GEN_23[0x10U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_613)
? __Vtemp2007[0x10U] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___GEN_23[0x11U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_613)
? __Vtemp2007[0x11U] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___GEN_23[0x12U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_613)
? __Vtemp2007[0x12U] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___GEN_23[0x13U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_613)
? __Vtemp2007[0x13U] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___GEN_23[0x14U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_613)
? __Vtemp2007[0x14U] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___GEN_23[0x15U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_613)
? __Vtemp2007[0x15U] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___GEN_23[0x16U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_613)
? __Vtemp2007[0x16U] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___GEN_23[0x17U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_613)
? __Vtemp2007[0x17U] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___GEN_23[0x18U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_613)
? __Vtemp2007[0x18U] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___GEN_23[0x19U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_613)
? __Vtemp2007[0x19U] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___GEN_23[0x1aU]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_613)
? __Vtemp2007[0x1aU] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___GEN_23[0x1bU]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_613)
? __Vtemp2007[0x1bU] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___GEN_23[0x1cU]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_613)
? __Vtemp2007[0x1cU] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___GEN_23[0x1dU]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_613)
? __Vtemp2007[0x1dU] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___GEN_23[0x1eU]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_613)
? __Vtemp2007[0x1eU] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___GEN_23[0x1fU]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_613)
? __Vtemp2007[0x1fU] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___GEN_23[0x20U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__monitor__DOT___T_613)
? (0x7fffU & __Vtemp2007[0x20U]) : 0U);
__Vtemp2012[0U] = 1U;
__Vtemp2012[1U] = 0U;
__Vtemp2012[2U] = 0U;
__Vtemp2012[3U] = 0U;
VL_SHIFTL_WWI(128,128,7, __Vtemp2013, __Vtemp2012, (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter_auto_out_a_bits_source));
__Vtemp2018[0U] = 1U;
__Vtemp2018[1U] = 0U;
__Vtemp2018[2U] = 0U;
__Vtemp2018[3U] = 0U;
VL_SHIFTL_WWI(128,128,7, __Vtemp2019, __Vtemp2018, (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter_auto_out_a_bits_source));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___inflight_T_2[0U]
= ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT__inflight[0U]
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___T_597)
? __Vtemp2013[0U] : 0U)) & (~ ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___T_610)
? __Vtemp2019[0U]
: 0U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___inflight_T_2[1U]
= ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT__inflight[1U]
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___T_597)
? __Vtemp2013[1U] : 0U)) & (~ ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___T_610)
? __Vtemp2019[1U]
: 0U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___inflight_T_2[2U]
= (0xffffU & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT__inflight[2U]
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___T_597)
? __Vtemp2013[2U] : 0U))
& (~ ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___T_610)
? __Vtemp2019[2U] : 0U))));
}
void VTestHarness::_settle__TOP__1070(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1070\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Variables
// Begin mtask footprint all:
WData/*1055:0*/ __Vtemp2027[33];
WData/*1055:0*/ __Vtemp2028[33];
// Body
__Vtemp2027[0U] = 0xfU;
__Vtemp2027[1U] = 0U;
__Vtemp2027[2U] = 0U;
__Vtemp2027[3U] = 0U;
__Vtemp2027[4U] = 0U;
__Vtemp2027[5U] = 0U;
__Vtemp2027[6U] = 0U;
__Vtemp2027[7U] = 0U;
__Vtemp2027[8U] = 0U;
__Vtemp2027[9U] = 0U;
__Vtemp2027[0xaU] = 0U;
__Vtemp2027[0xbU] = 0U;
__Vtemp2027[0xcU] = 0U;
__Vtemp2027[0xdU] = 0U;
__Vtemp2027[0xeU] = 0U;
__Vtemp2027[0xfU] = 0U;
__Vtemp2027[0x10U] = 0U;
__Vtemp2027[0x11U] = 0U;
__Vtemp2027[0x12U] = 0U;
__Vtemp2027[0x13U] = 0U;
__Vtemp2027[0x14U] = 0U;
__Vtemp2027[0x15U] = 0U;
__Vtemp2027[0x16U] = 0U;
__Vtemp2027[0x17U] = 0U;
__Vtemp2027[0x18U] = 0U;
__Vtemp2027[0x19U] = 0U;
__Vtemp2027[0x1aU] = 0U;
__Vtemp2027[0x1bU] = 0U;
__Vtemp2027[0x1cU] = 0U;
__Vtemp2027[0x1dU] = 0U;
__Vtemp2027[0x1eU] = 0U;
__Vtemp2027[0x1fU] = 0U;
__Vtemp2027[0x20U] = 0U;
VL_SHIFTL_WWI(1039,1039,10, __Vtemp2028, __Vtemp2027,
((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter_auto_out_a_bits_source)
<< 2U));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___GEN_23[0U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___T_610)
? __Vtemp2028[0U] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___GEN_23[1U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___T_610)
? __Vtemp2028[1U] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___GEN_23[2U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___T_610)
? __Vtemp2028[2U] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___GEN_23[3U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___T_610)
? __Vtemp2028[3U] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___GEN_23[4U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___T_610)
? __Vtemp2028[4U] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___GEN_23[5U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___T_610)
? __Vtemp2028[5U] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___GEN_23[6U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___T_610)
? __Vtemp2028[6U] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___GEN_23[7U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___T_610)
? __Vtemp2028[7U] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___GEN_23[8U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___T_610)
? __Vtemp2028[8U] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___GEN_23[9U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___T_610)
? __Vtemp2028[9U] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___GEN_23[0xaU]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___T_610)
? __Vtemp2028[0xaU] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___GEN_23[0xbU]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___T_610)
? __Vtemp2028[0xbU] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___GEN_23[0xcU]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___T_610)
? __Vtemp2028[0xcU] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___GEN_23[0xdU]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___T_610)
? __Vtemp2028[0xdU] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___GEN_23[0xeU]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___T_610)
? __Vtemp2028[0xeU] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___GEN_23[0xfU]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___T_610)
? __Vtemp2028[0xfU] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___GEN_23[0x10U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___T_610)
? __Vtemp2028[0x10U] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___GEN_23[0x11U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___T_610)
? __Vtemp2028[0x11U] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___GEN_23[0x12U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___T_610)
? __Vtemp2028[0x12U] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___GEN_23[0x13U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___T_610)
? __Vtemp2028[0x13U] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___GEN_23[0x14U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___T_610)
? __Vtemp2028[0x14U] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___GEN_23[0x15U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___T_610)
? __Vtemp2028[0x15U] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___GEN_23[0x16U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___T_610)
? __Vtemp2028[0x16U] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___GEN_23[0x17U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___T_610)
? __Vtemp2028[0x17U] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___GEN_23[0x18U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___T_610)
? __Vtemp2028[0x18U] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___GEN_23[0x19U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___T_610)
? __Vtemp2028[0x19U] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___GEN_23[0x1aU]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___T_610)
? __Vtemp2028[0x1aU] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___GEN_23[0x1bU]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___T_610)
? __Vtemp2028[0x1bU] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___GEN_23[0x1cU]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___T_610)
? __Vtemp2028[0x1cU] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___GEN_23[0x1dU]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___T_610)
? __Vtemp2028[0x1dU] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___GEN_23[0x1eU]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___T_610)
? __Vtemp2028[0x1eU] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___GEN_23[0x1fU]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___T_610)
? __Vtemp2028[0x1fU] : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___GEN_23[0x20U]
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__monitor__DOT___T_610)
? (0x7fffU & __Vtemp2028[0x20U]) : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__out_wivalid_0
= (3U & (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT___out_wifireMux_T_2)
& (((IData)(1U) << (3U & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter_auto_out_a_bits_address
>> 3U)))
>> 2U)) & (0U == (0x1fcU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter_auto_out_a_bits_address
>> 3U)))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__out_wivalid_4
= (7U & (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT___out_wifireMux_T_2)
& (((IData)(1U) << (3U & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter_auto_out_a_bits_address
>> 3U)))
>> 1U)) & (0U == (0x1fcU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter_auto_out_a_bits_address
>> 3U)))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__out_wivalid_10
= (0xfU & (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT___out_wifireMux_T_2)
& ((IData)(1U) << (3U & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter_auto_out_a_bits_address
>> 3U))))
& (0U == (0x1fcU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter_auto_out_a_bits_address
>> 3U)))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__repeater__DOT___GEN_0
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__repeater__DOT___T_1)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__repeater__DOT__full));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__monitor__DOT___T_619
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__monitor__DOT___a_first_T)
& (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__monitor__DOT__a_first_counter)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__monitor__DOT___T_651
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__monitor__DOT___a_first_T)
& (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__monitor__DOT__a_first_counter_1)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__monitor_io_in_a_ready
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT___portsAOI_in_0_a_ready_T)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT___portsAOI_in_0_a_ready_T_1));
}
void VTestHarness::_settle__TOP__1071(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1071\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar_auto_in_a_ready
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT___portsAOI_in_0_a_ready_T)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT___portsAOI_in_0_a_ready_T_1));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__monitor__DOT___T_692
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar_auto_in_d_bits_size)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__monitor__DOT__size_1))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_pbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__monitor__DOT___T_746
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_size_io_deq_bits_MPORT_data)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar_auto_in_d_bits_size))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_pbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__monitor__DOT___T_692
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__monitor_io_in_d_bits_size)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__monitor__DOT__size_1))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_pbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__monitor__DOT___T_746
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_size_io_deq_bits_MPORT_data)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__monitor_io_in_d_bits_size))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_pbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__monitor__DOT___T_722
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__monitor__DOT___T_719)
& (6U != (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar_auto_in_d_bits_opcode)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__monitor__DOT___T_684
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar_auto_in_d_bits_opcode)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__monitor__DOT__opcode_1))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_pbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__monitor__DOT___T_742
= ((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar_auto_in_d_bits_opcode)
== ((7U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_opcode_io_deq_bits_MPORT_data))
? 4U : ((6U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_opcode_io_deq_bits_MPORT_data))
? 4U : (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__monitor__DOT___GEN_30))))
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar_auto_in_d_bits_opcode)
== ((7U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_opcode_io_deq_bits_MPORT_data))
? 4U : ((6U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_opcode_io_deq_bits_MPORT_data))
? 5U : (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__monitor__DOT___GEN_30)))))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_pbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__monitor__DOT___T_807
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__monitor__DOT___d_first_T)
& (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__monitor__DOT__d_first_counter_2)))
& (6U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar_auto_in_d_bits_opcode)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__monitor__DOT___T_727
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__monitor__DOT___d_first_T)
& (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__monitor__DOT__d_first_counter_1)))
& (6U != (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar_auto_in_d_bits_opcode)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__monitor__DOT___T_722
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__monitor__DOT___T_719)
& (6U != (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__monitor_io_in_d_bits_opcode)));
}
void VTestHarness::_settle__TOP__1072(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__1072\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__monitor__DOT___T_684
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__monitor_io_in_d_bits_opcode)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__monitor__DOT__opcode_1))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_pbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__monitor__DOT___T_742
= ((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__monitor_io_in_d_bits_opcode)
== ((7U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_opcode_io_deq_bits_MPORT_data))
? 4U : ((6U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_opcode_io_deq_bits_MPORT_data))
? 4U : (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__monitor__DOT___GEN_30))))
| ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__monitor_io_in_d_bits_opcode)
== ((7U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_opcode_io_deq_bits_MPORT_data))
? 4U : ((6U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_opcode_io_deq_bits_MPORT_data))
? 5U : (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__monitor__DOT___GEN_30)))))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_pbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__monitor__DOT___T_807
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__monitor__DOT___d_first_T)
& (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__monitor__DOT__d_first_counter_2)))
& (6U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__monitor_io_in_d_bits_opcode)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__monitor__DOT___T_727
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__monitor__DOT___d_first_T)
& (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__monitor__DOT__d_first_counter_1)))
& (6U != (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__monitor_io_in_d_bits_opcode)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__monitor__DOT___T_517
= (((((4U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar_auto_in_d_bits_source))
| (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar_auto_in_d_bits_source)))
| (1U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar_auto_in_d_bits_source)))
| (2U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar_auto_in_d_bits_source)))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_pbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__monitor__DOT___T_696
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar_auto_in_d_bits_source)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__monitor__DOT__source_1))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_pbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__monitor__DOT___T_815
= (1U & ((0x1fU & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__monitor__DOT__inflight_1)
>> (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar_auto_in_d_bits_source)))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_pbus_0_reset_catcher_io_sync_reset)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__monitor__DOT___T_758
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar_auto_in_d_bits_size)
== (0xfU & (((0x13U >= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar_auto_in_d_bits_source)
<< 2U)) ? (0xfU
& (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__monitor__DOT__inflight_sizes
>>
((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__out_xbar_auto_in_d_bits_source)
<< 2U)))
: 0U) >> 1U))) | (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_pbus_0_reset_catcher_io_sync_reset));
}
| 120.842369
| 327
| 0.723823
|
vargandhi
|
f772ce052d7b44a38f2032aa6125bb5e9184eea2
| 1,748
|
cpp
|
C++
|
IL2CPP/Il2CppOutputProject/IL2CPP/libil2cpp/os/OSX/SystemCertificates.cpp
|
dngoins/AutographTheWorld-MR
|
24e567c8030b73a6942e25b36b7370667c649b90
|
[
"MIT"
] | 16
|
2018-10-13T12:29:06.000Z
|
2022-02-25T14:56:47.000Z
|
IL2CPP/Il2CppOutputProject/IL2CPP/libil2cpp/os/OSX/SystemCertificates.cpp
|
dngoins/AutographTheWorld-MR
|
24e567c8030b73a6942e25b36b7370667c649b90
|
[
"MIT"
] | 8
|
2020-03-10T23:11:09.000Z
|
2020-03-14T01:19:32.000Z
|
IL2CPP/Il2CppOutputProject/IL2CPP/libil2cpp/os/OSX/SystemCertificates.cpp
|
dngoins/AutographTheWorld-MR
|
24e567c8030b73a6942e25b36b7370667c649b90
|
[
"MIT"
] | 7
|
2020-06-09T13:16:30.000Z
|
2021-11-01T15:28:04.000Z
|
#include "os/c-api/il2cpp-config-platforms.h"
#if IL2CPP_TARGET_OSX
#include "os/SystemCertificates.h"
#include <Security/SecTrust.h>
#include <Security/SecCertificate.h>
#include <Security/SecImportExport.h>
namespace il2cpp
{
namespace os
{
void* SystemCertificates::OpenSystemRootStore()
{
CFArrayRef anchors = NULL;
OSStatus s;
s = SecTrustCopyAnchorCertificates(&anchors);
IL2CPP_ASSERT(s == noErr);
return (void*)anchors;
}
int SystemCertificates::EnumSystemCertificates(void* certStore, void** iter, int *format, int* size, void** data)
{
OSStatus s;
CFDataRef certData;
int numCerts = (int)CFArrayGetCount((CFArrayRef)certStore);
*format = DATATYPE_STRING;
// Order matters when it comes to certificates need to read in reverse
int currentCert = numCerts;
if (*iter != NULL)
{
currentCert = static_cast<int>(reinterpret_cast<intptr_t>(*iter));
}
SecCertificateRef cert = (SecCertificateRef)CFArrayGetValueAtIndex((CFArrayRef)certStore, (currentCert - 1));
s = SecItemExport(cert, kSecFormatPEMSequence, kSecItemPemArmour, NULL, &certData);
if (s == errSecSuccess)
{
char* certPEMStr = (char*)CFDataGetBytePtr(certData);
*iter = reinterpret_cast<void*>(static_cast<intptr_t>((currentCert - 1)));
*data = certPEMStr;
*size = sizeof(certPEMStr);
if ((currentCert - 1) > 0)
{
return TRUE;
}
}
return FALSE;
}
void SystemCertificates::CloseSystemRootStore(void* cStore)
{
CFRelease((CFArrayRef)cStore);
}
}
}
#endif
| 26.484848
| 117
| 0.621281
|
dngoins
|
f774e4c8b27ad670e8e2b76ba5b8a56a3be0261d
| 938
|
cpp
|
C++
|
lab26/1 - async.cpp
|
uiowa-cs-3210-0001/cs3210-labs
|
d6263d719a45257ba056a1ead7cc3dd428d377f3
|
[
"MIT"
] | 1
|
2019-01-24T14:04:45.000Z
|
2019-01-24T14:04:45.000Z
|
lab26/1 - async.cpp
|
uiowa-cs-3210-0001/cs3210-labs
|
d6263d719a45257ba056a1ead7cc3dd428d377f3
|
[
"MIT"
] | 1
|
2019-01-24T18:32:45.000Z
|
2019-01-28T04:10:28.000Z
|
lab26/1 - async.cpp
|
uiowa-cs-3210-0001/cs3210-labs
|
d6263d719a45257ba056a1ead7cc3dd428d377f3
|
[
"MIT"
] | 1
|
2019-02-07T00:28:20.000Z
|
2019-02-07T00:28:20.000Z
|
#include <iostream>
#include <vector>
#include <future>
#include <cmath>
#include <chrono>
using namespace std;
using namespace std::chrono;
bool is_prime( long n )
{
auto const sqrt_n = sqrt( n );
for ( long i = 2; i <= sqrt_n; ++i )
if ( ( n % i ) == 0 )
return false;
return true;
}
vector<long> find_primes( long max )
{
vector<long> result;
for ( long i = 2; i <= max; ++i )
if ( is_prime( i ) )
result.push_back( i );
return result;
}
int main()
{
// auto start_time = high_resolution_clock::now();
auto primes = find_primes( 10000000 );
// auto end_time = high_resolution_clock::now();
// auto duration = duration_cast<microseconds>( end_time - start_time ).count();
// cout << "Execution time (ms): " << duration << endl;
cout << "Number of primes: " << primes.size() << endl;
cout << "Max primes: " << primes.back() << endl;
}
| 21.318182
| 84
| 0.578891
|
uiowa-cs-3210-0001
|
f7757c023dd41c7fe70cf21a00dd0b31fd19815e
| 1,282
|
cpp
|
C++
|
core/src/system/CollisionDamage.cpp
|
Floriantoine/MyHunter_Sfml
|
8744e1b03d9d5fb621f9cba7619d9d5dd943e428
|
[
"MIT"
] | null | null | null |
core/src/system/CollisionDamage.cpp
|
Floriantoine/MyHunter_Sfml
|
8744e1b03d9d5fb621f9cba7619d9d5dd943e428
|
[
"MIT"
] | null | null | null |
core/src/system/CollisionDamage.cpp
|
Floriantoine/MyHunter_Sfml
|
8744e1b03d9d5fb621f9cba7619d9d5dd943e428
|
[
"MIT"
] | null | null | null |
#include "system/CollisionDamage.hpp"
#include "components/Damage.hpp"
#include "components/HealthComponent.hpp"
#include "components/SolidBlock.hpp"
#include "components/systemActivator/HaveCollisionDamage.hpp"
namespace systems {
void CollisionDamage::update(long elapsedTime)
{
auto array = this->_componentManager
->getComponentList<components::HaveCollisionDamage>();
for (auto &it: array) {
components::SolidBlock *solidC =
this->_componentManager->getComponent<components::SolidBlock>(
it.first);
if (solidC) {
if (solidC->_haveCollision && solidC->_targetsId.size()) {
components::Damage *damageC =
this->_componentManager->getComponent<components::Damage>(
solidC->_targetsId[0]);
if (damageC) {
components::HealthComponent *healthC =
this->_componentManager
->getComponent<components::HealthComponent>(
it.first);
if (healthC) {
healthC->health -= damageC->_damage;
}
}
}
}
}
};
} // namespace systems
| 36.628571
| 78
| 0.549142
|
Floriantoine
|
f775caf6faef2f359066287a55bc67c54e095508
| 1,490
|
hpp
|
C++
|
src/Switch.System.Drawing/include/Switch/System/Drawing/StringFormat.hpp
|
victor-timoshin/Switch
|
8e8e687a8bdc4f79d482680da3968e9b3e464b8b
|
[
"MIT"
] | 4
|
2020-02-11T13:22:58.000Z
|
2022-02-24T00:37:43.000Z
|
src/Switch.System.Drawing/include/Switch/System/Drawing/StringFormat.hpp
|
sgf/Switch
|
8e8e687a8bdc4f79d482680da3968e9b3e464b8b
|
[
"MIT"
] | null | null | null |
src/Switch.System.Drawing/include/Switch/System/Drawing/StringFormat.hpp
|
sgf/Switch
|
8e8e687a8bdc4f79d482680da3968e9b3e464b8b
|
[
"MIT"
] | 2
|
2020-02-01T02:19:01.000Z
|
2021-12-30T06:44:00.000Z
|
/// @file
/// @brief Contains Switch::System::Drawing::Graphics class.
#pragma once
#include <Switch/System/Object.hpp>
#include "StringAlignment.hpp"
namespace Switch {
/// @brief The System namespace contains fundamental classes and base classes that define commonly-used value and reference data types, events and event handlers, interfaces, attributes, and processing exceptions.
namespace System {
/// @brief The System::Drawing namespace provides access to GDI+ basic graphics functionality. More advanced functionality is provided in the System::Drawing::Drawing2D, System::Drawing::Imaging, and System::Drawing::Text namespaces.
namespace Drawing {
/// @par Library
/// Switch.System.Drawing
class system_drawing_export_ StringFormat : public Object {
public:
StringFormat() {}
StringFormat(const StringFormat& stringFormat) : alignment(stringFormat.alignment), lineAlignment(stringFormat.lineAlignment) {}
StringFormat& operator=(const StringFormat&) = default;
property_<StringAlignment> Alignment {
get_ {return this->alignment;},
set_ {this->alignment = value;}
};
property_<StringAlignment> LineAlignment {
get_ {return this->lineAlignment;},
set_ {this->lineAlignment = value;}
};
private:
StringAlignment alignment = StringAlignment::Near;
StringAlignment lineAlignment = StringAlignment::Near;
};
}
}
}
| 39.210526
| 237
| 0.695973
|
victor-timoshin
|
f782b10bdb28a5de394736df26a6b42bbe458c4e
| 187
|
cpp
|
C++
|
src/TimestampedMsgPtrQueue.cpp
|
r2p/Middleware
|
6438bdef16671482ecc1330679fa56439f916c61
|
[
"BSD-2-Clause"
] | 1
|
2020-11-26T04:21:41.000Z
|
2020-11-26T04:21:41.000Z
|
src/TimestampedMsgPtrQueue.cpp
|
r2p/Middleware
|
6438bdef16671482ecc1330679fa56439f916c61
|
[
"BSD-2-Clause"
] | null | null | null |
src/TimestampedMsgPtrQueue.cpp
|
r2p/Middleware
|
6438bdef16671482ecc1330679fa56439f916c61
|
[
"BSD-2-Clause"
] | 1
|
2020-11-26T04:21:47.000Z
|
2020-11-26T04:21:47.000Z
|
#include <r2p/TimestampedMsgPtrQueue.hpp>
namespace r2p {
TimestampedMsgPtrQueue::TimestampedMsgPtrQueue(Entry array[], size_t length)
:
impl(array, length)
{}
} // namespace r2p
| 13.357143
| 76
| 0.748663
|
r2p
|
f787372ad5765cffb3e2e4a0642946a13034aef8
| 857
|
cpp
|
C++
|
codeforces/C - The Phone Number/Wrong answer on pretest 9 (2).cpp
|
kzvd4729/Problem-Solving
|
13b105e725a4c2f8db7fecc5d7a8f932b9fef4ab
|
[
"MIT"
] | 1
|
2022-02-11T16:55:36.000Z
|
2022-02-11T16:55:36.000Z
|
codeforces/C - The Phone Number/Wrong answer on pretest 9 (2).cpp
|
kzvd4729/Problem-Solving
|
13b105e725a4c2f8db7fecc5d7a8f932b9fef4ab
|
[
"MIT"
] | null | null | null |
codeforces/C - The Phone Number/Wrong answer on pretest 9 (2).cpp
|
kzvd4729/Problem-Solving
|
13b105e725a4c2f8db7fecc5d7a8f932b9fef4ab
|
[
"MIT"
] | null | null | null |
/****************************************************************************************
* @author: kzvd4729 created: Aug/08/2018 21:46
* solution_verdict: Wrong answer on pretest 9 language: GNU C++14
* run_time: 30 ms memory_used: 400 KB
* problem: https://codeforces.com/contest/1017/problem/C
****************************************************************************************/
#include<bits/stdc++.h>
#define long long long
using namespace std;
const int N=1e5;
int n,arr[N+2],now;
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
cin>>n;
for(int i=1;i<=n;i+=2)
{
if(i+1<=n)cout<<i+1<<" ";
cout<<i<<" ";
}
cout<<endl;
return 0;
}
| 35.708333
| 111
| 0.369895
|
kzvd4729
|
f788e70bd033e59dd97bbaf43319dcf99c0fa906
| 4,612
|
hh
|
C++
|
contribs/qecode/OptVar.hh
|
guidotack/gecode
|
027c57889d66dd26ad8e1a419c2cda22ab0cf305
|
[
"MIT-feh"
] | 216
|
2016-07-11T12:44:44.000Z
|
2022-03-24T01:48:06.000Z
|
contribs/qecode/OptVar.hh
|
guidotack/gecode
|
027c57889d66dd26ad8e1a419c2cda22ab0cf305
|
[
"MIT-feh"
] | 105
|
2018-02-01T15:51:15.000Z
|
2022-03-05T16:10:36.000Z
|
contribs/qecode/OptVar.hh
|
guidotack/gecode
|
027c57889d66dd26ad8e1a419c2cda22ab0cf305
|
[
"MIT-feh"
] | 73
|
2016-02-15T07:09:36.000Z
|
2022-03-22T23:10:26.000Z
|
/**** , [ OptVar.hh ],
Copyright (c) 2008 Universite d'Orleans - Jeremie Vautard
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.
*************************************************************************/
#ifndef __QECODE_OPTVAR__
#define __QECODE_OPTVAR__
#include "Strategy.hh"
#include <vector>
/** \brief Abstract class for an Aggregator
*
* An aggregator is defined as a function Multiset_of_int -> int. From an implementation
* point of view, this multiset is a vector of int.
*/
class QECODE_VTABLE_EXPORT Aggregator {
public:
virtual int eval(vector<int> values)=0;
virtual ~Aggregator() {}
};
/** \brief Sum aggregator
*
* This aggregator computes the sum of all elements of the multiset
*/
class QECODE_VTABLE_EXPORT AggregatorSum : public Aggregator{
public:
QECODE_EXPORT virtual int eval(vector<int> values) {
int cpt=0;
for (int i=0;i<values.size();i++)
cpt += values[i];
return cpt;
}
virtual ~AggregatorSum() {}
};
/** \brief Mean aggregator
*
* This aggregator computes the mean of all elements of the multiset
*/
class QECODE_VTABLE_EXPORT AggregatorMean : public Aggregator{
public:
QECODE_EXPORT virtual int eval(vector<int> values) {
int size=values.size();
if (size == 0) return 0;
int cpt=0;
for (int i=0;i<size; i++)
cpt += values[i];
cpt = cpt / size;
return cpt;
}
virtual ~AggregatorMean() {}
};
/** \brief Abstract class for an optimization variable
*
* This class defines the interface of an optimization variable, which can be either an existential variable, of the result of an aggregator function
*/
class QECODE_VTABLE_EXPORT OptVar {
public:
QECODE_EXPORT virtual int getVal(Strategy s)=0; ///< returns value of this optimization variable in the substrategy s
QECODE_EXPORT virtual int getScope()=0; ///< returns the scope where this optimization variable belong
virtual ~OptVar() {}
};
/** \brief Existential optimization variable
*
* This class defines an existential optimization variable. This variabe is just an other point of view for an existential variable of the problem.
*/
class QECODE_VTABLE_EXPORT ExistOptVar : public OptVar {
private:
int varId;
int scopeId;
public:
QECODE_EXPORT ExistOptVar(int var,int scope);
QECODE_EXPORT virtual int getVal(Strategy s);
QECODE_EXPORT virtual int getScope();
virtual ~ExistOptVar() {}
};
/** \brief Universal optimization variable (aggregator result)
*
* This class defines a universal optimization variable. Such a variable represents the result of an aggregator on the set of values that an inner
* optimization variable takes in every sub-strategy of the current scope.
*/
class QECODE_VTABLE_EXPORT UnivOptVar : public OptVar {
private:
int scopeId;
OptVar* var;
Aggregator* fct;
public:
/** \brief constructor for an universal optimization variable
*
* Builds a universal optimzation variable at a given (universal) scope, that will represent the result of the agg aggregator on the set of all values
* taken by the optimization variable zevar in each substrategy below the current point.
* @param scope the scope where this optimization variable belong
* @param zevar the inner optimization variable that will be aggregated
* @param agg the aggregator function to be used
*/
QECODE_EXPORT UnivOptVar(int scope,OptVar* zevar,Aggregator* agg);
QECODE_EXPORT virtual int getVal(Strategy s);
QECODE_EXPORT virtual int getScope();
virtual ~UnivOptVar() {delete fct;}
};
#endif
| 36.896
| 157
| 0.719861
|
guidotack
|
f78b6d70bfd35ac8a14dc8c162a96e41dd51acd0
| 1,064
|
cpp
|
C++
|
src/rasperi_app/rasperi_about_dialog.cpp
|
kuumies/rasperi
|
5e854a3c15e788a714b61395fd2064a037154610
|
[
"MIT"
] | null | null | null |
src/rasperi_app/rasperi_about_dialog.cpp
|
kuumies/rasperi
|
5e854a3c15e788a714b61395fd2064a037154610
|
[
"MIT"
] | null | null | null |
src/rasperi_app/rasperi_about_dialog.cpp
|
kuumies/rasperi
|
5e854a3c15e788a714b61395fd2064a037154610
|
[
"MIT"
] | null | null | null |
/* ---------------------------------------------------------------- *
Antti Jumpponen <kuumies@gmail.com>
The implementation of kuu::rasperi::AboutDialog class.
* ---------------------------------------------------------------- */
#include "rasperi_about_dialog.h"
#include "ui_rasperi_about_dialog.h"
namespace kuu
{
namespace rasperi
{
/* ---------------------------------------------------------------- *
* ---------------------------------------------------------------- */
struct AboutDialog::Impl
{
Ui::AboutDialog ui;
};
/* ---------------------------------------------------------------- *
* ---------------------------------------------------------------- */
AboutDialog::AboutDialog(QWidget *parent)
: QDialog(parent)
, impl(std::make_shared<Impl>())
{
impl->ui.setupUi(this);
}
/* ---------------------------------------------------------------- *
* ---------------------------------------------------------------- */
void AboutDialog::on_closeButton_clicked()
{
accept();
}
} // namespace rasperi
} // namespace kuu
| 27.282051
| 70
| 0.333647
|
kuumies
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.