gematria

package module
v1.0.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 15, 2025 License: Apache-2.0 Imports: 8 Imported by: 3

README

Gematria

This package provides you the ability to transform a string into 6 numbers called Gematria. The three numbers are:

Kind Example String Example Score
Gematria.English Andrei 306
Gematria.Jewish Andrei 139
Gematria.Simple Andrei 51
Gematria.Mystery Andrei 2264
Gematria.Majestic Andrei 153
Gematria.Eights Andrei 338

When tools like Gematrix.org are used they return interesting results that share the similar scores with their results. For example:

Kind Score Gematrix Entry
English 306 Michael
English 306 BRICS
English 306 Batman
English 306 GESARA
English 306 Rome
English 306 Micheal
English 306 Elite
Kind Score Gematrix Entry
Jewish 139 Google
Jewish 139 Sin
Jewish 139 Golden Age
Jewish 139 Math
Jewish 139 Nikolai
Jewish 139 Agora
Kind Score Gematrix Entry
Simple 306 Michael
Simple 306 BRICS
Simple 306 Batman
Simple 306 GESARA
Simple 306 Rome
Simple 306 Micheal
Simple 306 Elite

The word Andrei in Gematria is expressed as English Michael. The Jewish expression of Andrei is the Golden Age. I am building multi-generational wealth and these utilities are part of how I am doing that. You can either program or be programmed, and I choose to program. Go is such a powerful programming language because of the memetics that it natively supports programmers to use.

Religious scholars have used Gematria as a mechanism for seeing relationships between words. Their relationships are the numbers that they share in common with each other. Those numbers are governed by the laws of 3 6 and 9. The power of 3 6 and 9 is very real and you are encouraged to use it. Therefore, this package was created... so that you may use it.

Package Installation

You will need to download this package to your Go project should you wish to use it.

go get -u github.com/andreimerlescu/gematria

Usage

Here is an example program that uses this package.

package main

import (
	"fmt"
	"github.com/andreimerlescu/gematria"
)

func main(){
	name := "yah i love yahuah and yah i am saint andrei"
	gematria := gematria.FromString(name)
	fmt.Printf("name = %v ; gematria = %v", name, gematria)
}

Error Handling

In gematria, errors like overflow or invalid input are nullified by returning 0, reflecting the numerological principle of harmony over disruption.

Future Proof

This package has no dependencies and will not require to be updated in the future given that Gematria is effectively a constant as unchangeable as the value of Pi. Therefore, the long term utilization of this package can safely be integrated into many types of projects.

Additional Ciphers Added

The EIGHTS Cipher is a new addition to the Gematria package. A begins at 3, B is 5, when combined AB you get 3+5=8 which is C. Then D is 16 and it increases by 8 until Z.

The MYSTERY Cipher is a new addition to the Gematria package. When developing this package, I asked the spirit to guide me and the numbers I chose was the numbers I chose. They are indeed a mystery.

The MAJESTIC Cipher is a new addition to the Gematria package. Starting at 3, incrementing by 3, it gets to Z with a value of 78 (3*26 letters). JKR is 30 33 54 which simplifies to 999. JFK 30 18 33 which simplifies to 999. Therefore JKR === JFK in the MAJESTIC UNDERSTANDING of what these numbers actually mean. Nikola Tesla understood it, and its worthy of me to program the ciphers using these numbers. They are worthy of studying too.

Contribution

If you wish to improve this code, please fork the repository and submit your pull request with your changes.

License

This package is licensed with the Apache 2.0 license so you can use it in your applications while giving proper credit where credit is due for creating this package in the first place.

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func Combine added in v1.0.1 

func Combine(in ...uint64) (uint64, error)

Combine accepts multiple uint64 values and merges them like the Gematria.Combine method does

func EightsCodes added in v1.0.1 

func EightsCodes() map[string]uint64

EightsCodes returns the Unsigned Integer Codes for Eights Gematria

func EnglishCodes added in v1.0.1 

func EnglishCodes() map[string]uint64

EnglishCodes returns the Unsigned Integer Codes for English Gematria

func JewishCodes added in v1.0.1 

func JewishCodes() map[string]uint64

JewishCodes returns the Unsigned Integer Codes for Jewish Gematria

func Majestic 

func Majestic(in uint64, err error) (out bool)

Majestic determines if the in uint64 digits are only 3, 6 or 9

func MajesticCodes added in v1.0.1 

func MajesticCodes() map[string]uint64

MajesticCodes returns the Unsigned Integer Codes for Majestic Gematria

func MajesticGematria 

func MajesticGematria(in Gematria, choices ...ComboType) (out uint64)

MajesticGematria - TODO - Update this function later to be more majestic than just an (out uint64)

func MysteryCodes added in v1.0.1 

func MysteryCodes() map[string]uint64

MysteryCodes returns the Unsigned Integer Codes for Mystery Gematria

func SimpleCodes added in v1.0.1 

func SimpleCodes() map[string]uint64

SimpleCodes returns the Unsigned Integer Codes for Simple Gematria

func Simplify 

func Simplify(in uint64) (out uint64, err error)

Simplify takes a uint64 and recursively (up to 9 times) reduces a number like 1776 to 3. 

Example: 1776 = 3
      1+7+7 = 15 becomes (15)6 = 3 ; becomes (1+5=6)6 = 3 ; becomes 6+6 = 12 becomes 1+2 becomes 3

Therefore: Simplify(1776) = 3

func SimplifyWithError added in v1.0.1 

func SimplifyWithError(in uint64, err error) (out uint64, e error)

SimplifyWithError accepts a uint64, error combo and performs Simplify on it or returns 0 for an error

func Types added in v1.0.1 

func Types() []string

Types returns a slice of the Gematria keys as strings

Types

type ComboType 

type ComboType string

ComboType is a string for the name of the flavor of Gematria you're displaying as a uint64 

const (
	CT_S      ComboType = "simple"
	CT_J      ComboType = "jewish"
	CT_E      ComboType = "english"
	CT_MY     ComboType = "mystery"
	CT_MJ     ComboType = "majestic"
	CT_EI     ComboType = "eights"
	CT_SJ     ComboType = "simple jewish"
	CT_SE     ComboType = "simple english"
	CT_SMY    ComboType = "simple mystery"
	CT_SMJ    ComboType = "simple majestic"
	CT_SEI    ComboType = "simple eights"
	CT_JE     ComboType = "jewish english"
	CT_JMY    ComboType = "jewish mystery"
	CT_JMJ    ComboType = "jewish majestic"
	CT_JEI    ComboType = "jewish eights"
	CT_MYMJ   ComboType = "mystery majestic"
	CT_MYEI   ComboType = "mystery eights"
	CT_EIMJ   ComboType = "eights majestic"
	CT_SJE    ComboType = "simple jewish english"
	CT_SJMY   ComboType = "simple jewish mystery"
	CT_SJMJ   ComboType = "simple jewish majestic"
	CT_SJEI   ComboType = "simple jewish majestic"
	CT_SEMY   ComboType = "simple english mystery"
	CT_SEMJ   ComboType = "simple english majestic"
	CT_SEEI   ComboType = "simple english eights"
	CT_JEMY   ComboType = "jewish english mystery"
	CT_JEMJ   ComboType = "jewish english majestic"
	CT_JEEI   ComboType = "jewish english eights"
	CT_EMYMJ  ComboType = "english mystery majestic"
	CT_EMYEI  ComboType = "english mystery eights"
	CT_EMJEI  ComboType = "english majestic eights"
	CT_MJMYEI ComboType = "majestic mystery eights"
)

define the combination types for Gematria

func ComboTypes added in v1.0.1 

func ComboTypes() []ComboType

ComboTypes returns a slice of ComboType that has all supported combinations by the package

type Gematria 

type Gematria struct {
	Jewish   uint64 `json:"jewish" yaml:"Jewish"`
	English  uint64 `json:"english" yaml:"English"`
	Simple   uint64 `json:"simple" yaml:"Simple"`
	Mystery  uint64 `json:"mystery" yaml:"Mystery"`
	Majestic uint64 `json:"majestic" yaml:"Majestic"`
	Eights   uint64 `json:"eights" yaml:"Eights"`
	// contains filtered or unexported fields
}

Gematria stores the original string and the various Gematria uint64 values

func FromString 

func FromString(in string) (out Gematria)

FromString is an alias to NewGematria that suppresses the error if one is present

func NewGematria 

func NewGematria(data string) (Gematria, error)

NewGematria calculates the value of data and returns Gematria and an error

func (Gematria) Combine added in v1.0.1 

func (s Gematria) Combine(fields ...ComboType) (uint64, error)

Combine reads multiple ComboType fields and concatenates the digits then converts to uint64 otherwise 0 is returned

func (Gematria) EnglishEights added in v1.0.1 

func (s Gematria) EnglishEights() uint64

EnglishEights uses the Gematria.English and Gematria.Eights to merge the two integers into a new string, then return the parsed uint64 of the result. If an error occurs, 0 is returned.

func (Gematria) EnglishMystery added in v1.0.1 

func (s Gematria) EnglishMystery() uint64

EnglishMystery uses the Gematria.English and Gematria.Mystery to merge the two integers into a new string, then return the parsed uint64 of the result. If an error occurs, 0 is returned.

func (Gematria) JSON added in v1.0.1 

func (s Gematria) JSON() string

JSON compiles the Gematria result into a formatted JSON string

func (Gematria) JewishEights added in v1.0.1 

func (s Gematria) JewishEights() uint64

JewishEights uses the Gematria.Jewish and Gematria.Eights to merge the two integers into a new string, then return the parsed uint64 of the result. If an error occurs, 0 is returned.

func (Gematria) MajesticEights added in v1.0.1 

func (s Gematria) MajesticEights() uint64

MajesticEights uses the Gematria.Majestic and Gematria.Eights to merge the two integers into a new string, then return the parsed uint64 of the result. If an error occurs, 0 is returned.

func (Gematria) MajesticMystery added in v1.0.1 

func (s Gematria) MajesticMystery() uint64

MajesticMystery uses the Gematria.Majestic and Gematria.Mystery to merge the two integers into a new string, then return the parsed uint64 of the result. If an error occurs, 0 is returned.

func (Gematria) MajesticMysteryEights added in v1.0.1 

func (s Gematria) MajesticMysteryEights() uint64

MajesticMysteryEights uses the Gematria.Majestic Gematria.Mystery and Gematria.Eights to merge the two integers into a new string, then return the parsed uint64 of the result. If an error occurs, 0 is returned.

func (Gematria) MysteryEights added in v1.0.1 

func (s Gematria) MysteryEights() uint64

MysteryEights uses the Gematria.Mystery and Gematria.Eights to merge the two integers into a new string, then return the parsed uint64 of the result. If an error occurs, 0 is returned.

func (Gematria) MysteryJewish added in v1.0.1 

func (s Gematria) MysteryJewish() uint64

MysteryJewish uses the Gematria.Mystery and Gematria.Jewish to merge the two integers into a new string, then return the parsed uint64 of the result. If an error occurs, 0 is returned.

func (Gematria) ReadCombo added in v1.0.1 

func (s Gematria) ReadCombo(ct ...ComboType) uint64

ReadCombo accepts multiple ComboType and runs MajesticGematria on those pairs and returns the simplified uint64

func (Gematria) SimpleEights added in v1.0.1 

func (s Gematria) SimpleEights() uint64

SimpleEights uses the Gematria.Simple and Gematria.Eights to merge the two integers into a new string, then return the parsed uint64 of the result. If an error occurs, 0 is returned.

func (Gematria) SimpleEnglish added in v1.0.1 

func (s Gematria) SimpleEnglish() uint64

SimpleEnglish uses the Gematria.Simple and Gematria.English to merge the two integers into a new string, then return the parsed uint64 of the result. If an error occurs, 0 is returned.

func (Gematria) SimpleJewish added in v1.0.1 

func (s Gematria) SimpleJewish() uint64

SimpleJewish uses the Gematria.Simple and Gematria.Jewish to merge the two integers into a new string, then return the parsed uint64 of the result. If an error occurs, 0 is returned.

func (Gematria) SimpleJewishEnglish added in v1.0.1 

func (s Gematria) SimpleJewishEnglish() uint64

SimpleJewishEnglish uses the Gematria.Simple Gematria.Jewish and Gematria.English to merge the two integers into a new string, then return the parsed uint64 of the result. If an error occurs, 0 is returned.

func (Gematria) SimpleMystery added in v1.0.1 

func (s Gematria) SimpleMystery() uint64

SimpleMystery uses the Gematria.Simple and Gematria.Mystery to merge the two integers into a new string, then return the parsed uint64 of the result. If an error occurs, 0 is returned.

func (Gematria) SimplifiedEights added in v1.0.1 

func (s Gematria) SimplifiedEights() (i uint64)

SimplifiedEights discards the error from Simplify and returns the uint64 if it can be simplified, otherwise 0 is returned

func (Gematria) SimplifiedEnglish added in v1.0.1 

func (s Gematria) SimplifiedEnglish() (i uint64)

SimplifiedEnglish discards the error from Simplify and returns the uint64 if it can be simplified, otherwise 0 is returned

func (Gematria) SimplifiedJewish added in v1.0.1 

func (s Gematria) SimplifiedJewish() (i uint64)

SimplifiedJewish discards the error from Simplify and returns the uint64 if it can be simplified, otherwise 0 is returned

func (Gematria) SimplifiedMajestic added in v1.0.1 

func (s Gematria) SimplifiedMajestic() (i uint64)

SimplifiedMajestic discards the error from Simplify and returns the uint64 if it can be simplified, otherwise 0 is returned

func (Gematria) SimplifiedMystery added in v1.0.1 

func (s Gematria) SimplifiedMystery() (i uint64)

SimplifiedMystery discards the error from Simplify and returns the uint64 if it can be simplified, otherwise 0 is returned

func (Gematria) SimplifiedSimple added in v1.0.1 

func (s Gematria) SimplifiedSimple() (i uint64)

SimplifiedSimple discards the error from Simplify and returns the uint64 if it can be simplified, otherwise 0 is returned

func (Gematria) Simplify added in v1.0.1 

func (s Gematria) Simplify() Gematria

Simplify uses the SimplifiedEnglish and other methods to modify the Gematria and return a new Gematria

func (Gematria) String 

func (s Gematria) String() string

String formats the output of the Gematria Struct

type ResultMap 

type ResultMap map[string]uint64

ResultMap stores the character string and the Gematria uint64 value

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.