|
Post by AnthroHeart on Apr 28, 2024 11:56:51 GMT
This is possibly the simplest C++ program for repeating the intention "I am Love."
#include <iostream> #include <string>
int main() { std::string process_intention; std::string intention = "I am Love.";
std::cout << "Repeating \"" << intention << "\" Press Ctrl-C to quit..."; do { process_intention = intention; } while (1);
return 0; }
You'd compile it to an executable using:
g++ -O3 -Wall -static example.cpp -o example.exe
|
|
|
Post by AnthroHeart on Apr 28, 2024 12:27:41 GMT
This is possibly the simplest Intention Repeating that uses Intention Multiplying to take your intention and make it 1GB in size. Note, this 1GB is duplicated because it's stored in 2 variables.
#include <iostream> #include <string>
int main() { std::string process_intention; std::string intention_value = ""; std::string intention = "I am Love.";
do { intention_value += intention; } while (intention_value.length() < 1024 * 1024 * 1024);
std::cout << "Repeating \"" << intention << "\" Press Ctrl-C to quit..."; do { process_intention = intention_value; } while (1);
return 0; } You'd compile it to an executable using:
g++ -O3 -Wall -static example.cpp -o example.exe
|
|
|
Post by AnthroHeart on Apr 28, 2024 13:17:29 GMT
To do Intention Multiplying, Hashing and Compression, here is perhaps the simplest way that looks good. Note, the 1GB default is used over two variables, using 2GB total RAM.
#include <iostream> #include <string> #include <cstring> #include <chrono> #include "picosha2.h" #include "zlib.h"
std::string FindSum(std::string a, std::string b) { std::vector<int> finalsum; int carry = 0;
int i = a.size() - 1; int j = b.size() - 1; while ((i >= 0) && (j >= 0)) { int x = (a[i] - '0') + (b[j] - '0') + carry; finalsum.push_back(x % 10); carry = x / 10; i--; j--; }
while (i >= 0) { int x = (a[i] - '0') + carry; finalsum.push_back(x % 10); carry = x / 10; i--; }
while (j >= 0) { int x = (b[j] - '0') + carry; finalsum.push_back(x % 10); carry = x / 10; j--; }
while (carry) { finalsum.push_back(carry % 10); carry = carry / 10; }
std::stringstream final_iter; std::copy(finalsum.rbegin(), finalsum.rend(), std::ostream_iterator<int>(final_iter, ""));
return final_iter.str(); }
std::string MultiplyStrings(const std::string &num1, const std::string &num2) { int len1 = num1.size(); int len2 = num2.size(); std::vector<int> result(len1 + len2, 0);
for (int i = len1 - 1; i >= 0; --i) { for (int j = len2 - 1; j >= 0; --j) { int mul = (num1[i] - '0') * (num2[j] - '0'); int sum = mul + result[i + j + 1];
result[i + j + 1] = sum % 10; result[i + j] += sum / 10; } }
std::string resultStr; for (int num : result) { if (!(resultStr.empty() && num == 0)) { resultStr.push_back(num + '0'); } }
return resultStr.empty() ? "0" : resultStr; }
std::string display_suffix(std::string num, int power, std::string designator) { if (power < 3) { return num; }
std::string s;
if (designator == "Iterations") { constexpr char iterations_suffix_array[] = {' ', 'k', 'M', 'B', 'T', 'q', 'Q', 's', 'S', 'O', 'N', 'D'}; s = iterations_suffix_array[power / 3]; } else // designator == "Frequency" { constexpr char frequency_suffix_array[] = {' ', 'k', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y', 'R'}; s = frequency_suffix_array[power / 3]; }
std::string str2 = num.substr(0, power % 3 + 1) + "." + num.substr(power % 3 + 1, 3) + s;
return str2; }
std::string compressMessage(const std::string &message) { z_stream zs; std::memset(&zs, 0, sizeof(zs));
if (deflateInit(&zs, Z_DEFAULT_COMPRESSION) != Z_OK) { return ""; // Compression initialization failed }
zs.next_in = reinterpret_cast<Bytef *>(const_cast<char *>(message.data())); zs.avail_in = message.size();
std::string compressed; char outbuffer[32768]; // Output buffer int ret; do { zs.next_out = reinterpret_cast<Bytef *>(outbuffer); zs.avail_out = sizeof(outbuffer);
ret = deflate(&zs, Z_FINISH);
if (compressed.size() < zs.total_out) { compressed.append(outbuffer, zs.total_out - compressed.size()); } } while (ret == Z_OK);
deflateEnd(&zs);
if (ret != Z_STREAM_END) { return ""; // Compression failed }
return compressed; }
int main() { std::string process_intention, intention_value, intention, hashed_intention, total_freq, total_iterations; long long unsigned int multiplier = 0, hash_multiplier = 0; long long unsigned int length_before_compression = 0, length_after_compression = 0, freq = 0; int digits_freq, digits_iterations; size_t GB = 1024 * 1024 * 1024;
std::cout << "Enter Intention: "; std::getline(std::cin, intention);
std::cout << "Multiplying..." << std::flush; intention_value.reserve(GB); do { intention_value.append(intention); multiplier++; } while (intention_value.size() < GB);
std::cout << "\nMultiplier: " << multiplier << std::endl; std::cout << "Hashing..." << std::flush;
hashed_intention = picosha2::hash256_hex_string(intention_value); intention_value = "";
do { intention_value.append(hashed_intention); hash_multiplier++; } while (intention_value.size() < GB);
std::cout << "\nHash Multiplier: " << hash_multiplier << std::endl;
std::cout << "Compressing..." << std::flush; length_before_compression = intention_value.length(); intention_value = compressMessage(intention_value); length_after_compression = intention_value.length();
std::cout << "\nCompression Factor: " << (length_before_compression / length_after_compression) << "X" << std::endl;
std::cout << "Repeating \"" << intention << "\" Press Ctrl-C to quit...\n"; auto start = std::chrono::high_resolution_clock::now(); auto end = std::chrono::high_resolution_clock::now();
do { process_intention = intention_value; freq++; end = std::chrono::high_resolution_clock::now(); if (std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() > 1000) { total_freq = MultiplyStrings(std::to_string(freq), std::to_string(multiplier)); total_freq = MultiplyStrings(total_freq, std::to_string(hash_multiplier)); total_iterations = FindSum(total_iterations, total_freq); digits_iterations = total_iterations.length(); digits_freq = total_freq.length(); freq = 0;
std::cout << display_suffix(total_iterations, digits_iterations - 1, "Iterations") << " Iterations. (" << display_suffix(total_freq, digits_freq - 1, "Frequency") << "Hz) \r"; start = std::chrono::high_resolution_clock::now(); }
} while (1);
return 0; }
It requires these files:
You'd compile it to executable using:
g++ -O3 -Wall -static example.cpp -o example.exe -lz
|
|
|
Post by AnthroHeart on Apr 30, 2024 21:11:11 GMT
Here's a simple Radionics Broadcaster in Python that lets you specify a Source and a Target file.
import copy
def read_file(file_path): try: with open(file_path, 'rb') as file: return file.read() except FileNotFoundError: print(f'"{file_path}" does not exist.') exit()
def main(): source_file = input("Enter Source File: ") target_file = input("Enter Target File: ")
source_content = read_file(source_file) target_content = read_file(target_file)
combined_content = source_content + target_content repetitions = 0 millions = 0
print("Broadcasting...Press Ctrl-C to Quit.")
try: while True: process_radionics = copy.deepcopy(combined_content) # Performs the Radionics Broadcast. repetitions = repetitions + 1 if repetitions % 10000000 == 0: millions += 10 print(f"\rRepetitions: {millions} Million", end='')
except KeyboardInterrupt: print("\nExiting...")
if __name__ == '__main__': main()
|
|