1.32

Author: zeightOFFICIAL

Applied/GaussEaster.h

@@ -1,15 +1,24 @@
 // Meeus.h
 
-#include <string>
 #include "_Utils.h"
 
 namespace easterday {
   /**
-  (ulong A) -> (string B)
-  Finds date B of the easter day in year A.
+  (unsigned long A) -> (string B)
+  Finds date B of the Easter day in year A.
   Uses Meeus algorithm to find Julian Orthodox
-  day of easter. Returns day B.
+  day of Easter. Returns day B.
   */
+  static string MeeusJulianEaster(ulong year);
+  /**
+  (unsigned long A) -> (string B)
+  Finds date B of the Easter day in year A.
+  Uses Meeus algorithm to find Gregorian Orthodox
+  day of Easter. Returns day B.
+  ! WORKS ONLY WITHIN 1901..2099 !
+  */
+  static string MeeusGregorianEaster(ulong year);
+
   static string MeeusJulianEaster(ulong year) {
     ulong newYear4 = year % 4, 
           newYear7 = year % 7, 
@@ -20,6 +29,32 @@ namespace easterday {
     ulong newMonth = (e / 31), 
           newDay = ((e % 31) + 1);
 
-    return std::to_string(newDay) + " " + monthName[newMonth - 1] + " " + std::to_string(year);
+    return std::to_string(newDay) + " " + monthCalling[newMonth - 1] + " " + std::to_string(year);
+  }
+
+  static string MeeusGregorianEaster(ulong year) {
+    if (year < 1900 || year > 2099) {
+      return "Cannot be found";
+    }
+    
+    ulong newYear4 = year % 4, 
+          newYear7 = year % 7, 
+          newYear19 = year % 19;
+    ulong d = (19 * newYear19 + 15) % 30,
+          e = (2 * newYear4 + 4 * newYear7 - d + 34) % 7;
+    e = d + e + 114;
+    ulong newMonth = (e / 31), 
+          newDay = ((e % 31) + 1);
+    newDay = newDay + 13;
+    if (newDay > 31 && newMonth == 3) {
+      newDay = newDay - 31;
+      newMonth = newMonth + 1;
+    }
+    else if (newDay > 30 && newMonth == 4){
+      newDay = newDay - 30;
+      newMonth = newMonth + 1;
+    }
+  
+    return std::to_string(newDay) + " " + monthCalling[newMonth - 1] + " " + std::to_string(year);
   }
 } // namespace applied

Applied/Meeus.h

@@ -2,21 +2,21 @@
 
 #include <string>
 
-namespace applied {
+namespace daycalling {
   typedef std::string string;
   typedef unsigned long ulong;
+  /**
+  (unsigned long A, unsigned long B, unsigned long C) -> (string D)
+  Finds day (calling) D of the date A.B.C (where
+  A - day, B - month, C - year). Uses Zeller
+  congruence. Returns day calling D.
+  */
   static string ZellerDayOfDate(ulong day, ulong month, ulong year);
 
   static const string callings[7] = {
       "Saturday",  "Sunday",   "Monday", "Tuesday",
       "Wednesday", "Thursday", "Friday"};
 
-  /**
-  (ulong A, ulong B, ulong C) -> (string D)
-  Finds day (calling) D of the date A.B.C (where
-  A - day, B - month, C - year). Uses Zeller
-  congruence. Returns day calling D.
-  */
   static string ZellerDayOfDate(ulong day, ulong month, ulong year) {
     if (month == 1) {
       month = 13;

Applied/ZellerCongruence.h

@@ -1,5 +1,5 @@
 // Utils.h
-// must be included and used in each hashing header file
+// must be included and used in Meeus.h header file
 // for ver 1.32
 
 #pragma once
@@ -9,8 +9,7 @@
 namespace easterday {
   typedef std::string string;
   typedef unsigned long ulong;
-
-  static const string monthName[12] = {
+  static const string monthCalling[12] = {
       "January", "February", "March",     "April",   "May",      "June",
       "July",    "August",   "September", "October", "November", "December"};
 }

Applied/_Utils.h

@@ -4,7 +4,6 @@
 
 namespace exponentiation {
   typedef int64_t int64;
-
   /**
     (double A, int64 B) -> (double C)
     Finds C of the A**B=C equation. Uses naive iteration.

Elementary/NaiveExp.h

@@ -4,7 +4,6 @@
 
 namespace exponentiation {
   typedef int64_t int64;
-
   /*
     (double A, int64 B) -> (double C)
     Finds C of the A**B=C equation. Uses squaring recursion.

Elementary/SquaringExp.h

@@ -1,4 +1,7 @@
 // Graph.h
+// Helping class for Graph algorithms.
+// Might be removed. If so, use algorihtms directly, without Graph and inherited classes.
+// for version 1.32
 
 #pragma once
 

Graph/Graph.h

@@ -15,7 +15,13 @@ namespace mst {
     void Unite(int x, int y);
     int Set(int i);
   };
-  
+
+  /**
+  (vector<vector<int>> A, int C) -> (vector<vector<int>> D)
+  Finds minimum spanning tree list D of edges list A.
+  With total number of vertices C. Uses Kruskal's algorithm. 
+  Returns MST list D.
+  */
   vector MSTKruskal(vector EdgeList, int NoVertex);
 
   DSU::DSU(int size) {

Graph/MinimumSpanningTree/Kruskal.h

@@ -1,4 +1,7 @@
 // MST.h
+// Helping class for Graph algorithms.
+// Might be removed. If so, use algorihtms directly, without Graph and inherited classes.
+// for version 1.32
 
 #pragma once
 

Graph/MinimumSpanningTree/MST.h

@@ -5,7 +5,12 @@
 
 namespace mst {
   #define INF 999999
-  typedef std::vector<std::vector<int>> vector;  
+  typedef std::vector<std::vector<int>> vector; 
+  /**
+  (vector<vector<int>> A) -> (vector<vector<int>> B)
+  Finds minimum spanning tree list B of distances matrix A.
+  Uses Prim's algorithm. Returns MST list B.
+  */
   vector MSTPrim(vector DistancesMatrix);
   int MinKey(int key[], bool visited[], int NoVertex);
 

Graph/MinimumSpanningTree/Prim.h

@@ -5,6 +5,11 @@
 
 namespace spg {
   typedef std::vector<std::vector<int>> vector;
+  /**
+  (vector<vector<int>> A) -> (vector<vector<int>> B)
+  Finds shortest path matrix B of distances matrix A.
+  Uses Dijsktra algorithm. Returns SP matrix B.
+  */
   vector DijkstraTable(vector DistancesMatrix);
   int Minkey(int key[], bool visited[], int vertices);
 

Graph/ShortestPath/Dijkstra.h

@@ -5,6 +5,11 @@
 
 namespace spg {
   typedef std::vector<std::vector<int>> vector;
+  /**
+  (vector<vector<int>> A) -> (vector<vector<int>> B)
+  Finds shortest path matrix B of distances matrix A.
+  Uses Floyd-Warshall algorithm. Returns SP matrix B.
+  */
   vector FloydTable(vector DistanceMatrix);
 
   vector FloydTable(vector DistancesMatrix) {

Graph/ShortestPath/FloydWarshall.h

@@ -5,6 +5,11 @@
 namespace spg {
   #define INF 999999
   typedef std::vector<std::vector<int>> vector;
+  /**
+  (vector<vector<int>> A) -> (vector<vector<int>> B)
+  Finds shortest path matrix B of distances matrix A.
+  Uses Johnson algorithm. Returns SP matrix B.
+  */
   vector JohnsonTable(vector DistancesMatrix);
 
   vector JohnsonTable(vector DistancesMatrix) {

Graph/ShortestPath/Johnson.h

@@ -1,4 +1,7 @@
 // SPG.h
+// Helping class for Graph algorithms.
+// Might be removed. If so, use algorihtms directly, without Graph and inherited classes.
+// for version 1.32
 
 #pragma once
 

Graph/ShortestPath/SPG.h

@@ -21,6 +21,11 @@ namespace hashing {
   typedef std::bitset<8> bitset8;
   typedef std::bitset<32> bitset32;
 
+  /**
+  (T A) -> (string B)
+  Converts A to hexadecimal contained in string B.
+  Return string B.
+  */
   template <typename T>
   static string intToHex(T number) {
     strstream stream;

Hashing/_Utils.h

@@ -4,13 +4,14 @@
 
 namespace hashing {
   static const ulong ADLER32_MOD = 65521;
-
   /**
   (string A) -> (string B)
   Creates checksum B of string A, using
   adler32 hashing function. 
   Return string B - checksum.
   */
+  static string adler32(const string data);
+
   static string adler32(const string data) {
     ulong length = data.length();
     uint32 a = 1, b = 0;

Hashing/adler32.h

@@ -5,14 +5,24 @@
 namespace hashing {
   static const uint32 FNV32_PRIME = 0x01000193;
   static const uint32 FNV32_OFFSET = 0x811c9dc5;
-
+  static const uint64 FNV64_PRIME = 0x00000100000001B3;
+  static const uint64 FNV64_OFFSET = 0xcbf29ce484222325;
   /**
   (string A) -> (string B)
   Creates checksum B of string A, using
   fnv132 hashing function. 
   Return string B - checksum.
   */
-  string fnv132(const string data) {
+  static string fnv132(const string data);
+  /**
+  (string A) -> (string B)
+  Creates checksum B of string A, using
+  fnv164 hashing function. 
+  Return string B - checksum.
+  */
+  static string fnv164(const string data);
+
+  static string fnv132(const string data) {
     ulong length = data.length();
     uint32 hash = FNV32_OFFSET;
 
@@ -24,16 +34,7 @@ namespace hashing {
     return intToHex(hash);
   }
 
-  static const uint64 FNV64_PRIME = 0x00000100000001B3;
-  static const uint64 FNV64_OFFSET = 0xcbf29ce484222325;
-
-  /**
-  (string A) -> (string B)
-  Creates checksum B of string A, using
-  fnv164 hashing function. 
-  Return string B - checksum.
-  */
-  string fnv164(const string data) {
+  static string fnv164(const string data) {
     ulong length = data.length();
     uint64 hash = FNV64_OFFSET;
 

Hashing/fnv.h

@@ -29,8 +29,8 @@ namespace hashing {
   SHA1 hashing function. 
   Return string B - hash.
   */
-  string sha1(const string data);
-}
+  static string sha1(const string data);
+} // namespace hashing
 
 namespace hashing {
   SHA1::SHA1() {
@@ -164,7 +164,7 @@ namespace hashing {
     return res.str();
   }
 
-  std::string sha1(const std::string data) {
+  static std::string sha1(const std::string data) {
     SHA1 hash;
     hash.update(data);
     return hash.final();

Hashing/sha1.h

@@ -45,7 +45,7 @@ namespace hashing {
   SHA256 hashing function. 
   Return string B - hash.
   */
-  string sha256(const string data);
+  static string sha256(const string data);
 } // namespace hashing
 
 namespace hashing {
@@ -184,7 +184,7 @@ namespace hashing {
     return (a & (b | c)) | (b & c);
   }
 
-  string sha256(const string data) {
+  static string sha256(const string data) {
     SHA256 hash;
     hash.update(data);
     return hash.final();

Hashing/sha2.h

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2022 Artemii Saganenko
+Copyright (c) 2022-2023 Artemii Saganenko
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

LICENSE

@@ -56,4 +56,5 @@
 <br>https://en.wikipedia.org/
 ## Applied
 * <strong>Zeller Congruence</strong> - is an algorithm devised by Christian Zeller in the 19th century to calculate the day of the week for any Julian or Gregorian calendar date. It can be considered to be based on the conversion between Julian day and the calendar date.
+* <strong>Meeus</strong> - is an algorithm for calculating the Julian Orthodox Easter day and Gregorian Orthodox Easter day (in between 1901..2099).
 <br><br>https://en.wikipedia.org/

README.md

@@ -4,7 +4,6 @@
 
 namespace picalc {
   typedef unsigned short ushort;
-
   /*
     (unsigned short A) -> (double B)
     Finds pi number B with precision of A.