Numerology Calculator

https://pkg.go.dev/github.com/LanderTome/numerologyCalculator
Admin
Numerology Calculator is a Go library that performs numerological calculations for names and dates...
Tokens:17,554
Snippets:123
Trust Score:9.6
Update:6 months ago
Show doc for...
Tokens:
Raw
### Install the package

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator

Use this command to add the package to your Go project.

```bash
go get "github.com/LanderTome/numerologyCalculator"
```

--------------------------------

### Example Output of Debug Method

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Illustrates the expected output format from the Debug method, showing the breakdown of name conversions and the final reduced number.

```text
Output:
G e o r g e
· 5 6 · · 5 = 16 = 7
W a s h i n g t o n
· 1 · · 9 · · · 6 · = 16 = 7

Reduce: 14 = 5

```

--------------------------------

### Example Output for Numerological Calculations

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Illustrative output format for various numerological calculations, showing letter values, sums, and reductions.

```text
Output:
K e v i n
2 · 4 · 5 = 11
N o r w o o d
5 · 9 5 · · 4 = 23 = 5
B a c o n
2 · 3 · 5 = 10 = 1
Reduce: 17 = 8
```

```text
Output:
K e v i n
2 5 4 9 5 = 25 = 7
N o r w o o d
5 6 9 5 6 6 4 = 41 = 5
B a c o n
2 1 3 6 5 = 17 = 8
Reduce: 20 = 2
```

```text
Output:
K e v i n
· 5 · 9 · = 14 = 5
N o r w o o d
· 6 · · 6 6 · = 18 = 9
B a c o n
· 1 · 6 · = 7
Reduce: 21 = 3
```

```text
Output:
Kevin Norwood Bacon ([5])
```

```text
Output:
Kevin Norwood Bacon ([7 8])
```

```text
+----+-------------------------+---+
|    |          NAME           | # |
+----+-------------------------+---+
|  1 | Abraham James Lincoln   | 3 |
|  2 | Abraham David Lincoln   | 5 |
|  3 | Abraham William Lincoln | 8 |
|  4 | Abraham Daniel Lincoln  | 8 |
|  5 | Abraham Joshua Lincoln  | 3 |
|  6 | Abraham Anthony Lincoln | 8 |
|  7 | Abraham Andrew Lincoln  | 3 |
|  8 | Abraham Kevin Lincoln   | 8 |
|  9 | Abraham Steven Lincoln  | 8 |
| 10 | Abraham Jacob Lincoln   | 3 |
+----+-------------------------+---+
```

--------------------------------

### Number System Conversion

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Function to get a NumberSystem from its string representation.

```APIDOC
## POST /websites/pkg_go_dev_github_com_landertome_numerologycalculator/GetNumberSystem

### Description
Converts a string representation of a number system into the NumberSystem type.

### Method
POST

### Endpoint
/websites/pkg_go_dev_github_com_landertome_numerologycalculator/GetNumberSystem

### Parameters
#### Request Body
- **s** (string) - Required - The string representation of the number system (e.g., "Pythagorean", "Chaldean").

### Request Example
```json
{
  "s": "Pythagorean"
}
```

### Response
#### Success Response (200)
- **numberSystem** (NumberSystem) - The corresponding NumberSystem type.
- **error** (string) - An error message if the conversion fails.

#### Response Example
```json
{
  "numberSystem": "Pythagorean",
  "error": null
}
```
```

--------------------------------

### Get Event and Life Path Numerology

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator

Extract specific numerological results for a calculated date. 'Event()' provides general numerology, while 'LifePath()' considers master numbers.

```go
event := name.Event()
lifePath := name.LifePath()
```

--------------------------------

### Initialize and populate the database

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator

Creates a database from a directory of CSV files using a DSN string.

```go
package main

import "github.com/LanderTome/numerologyCalculator/numerology"

func main() {
	dsn := "sqlite://file::memory:" // Example for testing
	namesDir := "test_names"
	if err := numerology.CreateDatabase(dsn, namesDir); err != nil {
		println(err.Error())
	}
}
```

--------------------------------

### GET /NameNumerology/UnknownCharacters

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Retrieves a list of characters from the name that cannot be converted to numerological values.

```APIDOC
## GET /NameNumerology/UnknownCharacters

### Description
Returns a set of characters that cannot be converted to numerological values. These characters are ignored in calculations.

### Method
GET

### Response
#### Success Response (200)
- **unknowns** (array of strings) - A list of characters that were ignored during calculation.
```

--------------------------------

### Initialize a name calculation

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator

Create a name object by specifying the number system, master numbers, and word reduction preference.

```go
package main

import "github.com/LanderTome/numerologyCalculator/numerology"

func main() {
	numberSystem := numerology.Pythagorean
	masterNumbers := []int{11, 22, 33}
	reduceWords := true
	name := numerology.Name("John Doe", numberSystem, masterNumbers, reduceWords)
}
```

--------------------------------

### Create Database Function

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Creates and populates the database with numerological calculations from CSV files. Specify the database connection string and the base directory for CSVs.

```go
func CreateDatabase(dsn string, baseDir string) error
```

```csv
john,M,10000
sara,F,9000
jack,M,8000


```

--------------------------------

### Define NameOpts configuration

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Configuration struct for defining the number system, master numbers, and word reduction behavior during calculations.

```go
type NameOpts struct {
	// NumberSystem is the numerological number system to use to convert the name into numbers.
	NumberSystem NumberSystem `json:"number_system"`

	// MasterNumbers are two (or more) digit numbers that should not be reduced because they are
	// considered to have special numerological value. The most commonly considered master numbers
	// are repeating digits. ex 11, 22, 33, 44, 55
	MasterNumbers []int `json:"master_numbers"`

	// ReduceWords determines whether a name is first separated into individual names that are
	// reduced independently before summing together and reduce a final time or if the whole
	// name is reduced all at once.
	ReduceWords bool `json:"reduce_words"`
}
```

--------------------------------

### GET /NameNumerology/Vowels

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Calculates the numerological value based on the vowel letters of a name, often referred to as the Heart's Desire or Soul's Urge number.

```APIDOC
## GET /NameNumerology/Vowels

### Description
Calculates the numerological value using only the vowel letters of the given name.

### Method
GET

### Response
#### Success Response (200)
- **result** (NumerologicalResult) - The calculated numerological value based on vowels.
```

--------------------------------

### Retrieve NumberSystem

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Fetches a specific NumberSystem instance by name, such as Pythagorean or Chaldean.

```go
func GetNumberSystem(s string) (NumberSystem, error)
```

--------------------------------

### Debug calculation steps

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator

Use the Debug method to visualize the breakdown of a calculation.

```go
package main

import "github.com/LanderTome/numerologyCalculator/numerology"

func main() {
	numberSystem := numerology.Pythagorean
	masterNumbers := []int{11, 22, 33}
	reduceWords := true
	name := numerology.Name("Janet Audrey Doe", numberSystem, masterNumbers, reduceWords)
	personality := name.Consonants()
	println(personality.Debug())
}
```

--------------------------------

### Functions

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Utility functions for database creation, date manipulation, and string conversion.

```APIDOC
## Functions

### CreateDatabase

```go
func CreateDatabase(dsn string, baseDir string) error
```

CreateDatabase function creates and populates the database table with the pre-populated numerological calculations. The argument dsn is the connection string for the database that will utilized. The argument baseDir is the directory where the CSV files are stored that contain the names that will populate the database. Each folder in the baseDir becomes a table in the database. This allows for multiple name sources.

The format for the CSV files is name, gender, popularity with no header. Gender is just a letter 'M' for male or 'F' female. Popularity is used to determine the sort order of the names. Each reoccurrence of the same name aggregates the popularity.

```
john,M,10000
sara,F,9000
jack,M,8000

```

### NewDate

```go
func NewDate(year, month, day int) (newDate time.Time)
```

NewDate is a wrapper to easily create a time.Time variable without entering hour, min, sec, nsec, loc since they are not important for any date calculation. Note: Golang time.Time always has a timezone. UTC is used, and the hour used is midday (12:00). This should help avoid situations where time.Time gets converted to a new time zone accidentally so the date isn't inadvertently changed.

### ToAscii

```go
func ToAscii(s string) string
```

ToAscii transliterates a unicode string to ascii string and removes extraneous newline chars and whitespace. This conversion is not 100% due to complexities of language. See this article by Sean M. Burke for more information. https://interglacial.com/~sburke/tpj/as_html/tpj22.html
```

--------------------------------

### Implement Debug Method for NumerologicalResult

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Provides a method to generate a printable string summarizing the numerological conversion process. This is useful for debugging and displaying results.

```go
func (n NumerologicalResult) Debug() (debug string)
```

--------------------------------

### Database Connection Variable

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Global variable holding the database connection. Supports SQLite, MySQL, and PostgreSQL via Gorm. Can be replaced for other database solutions.

```go
var DB *gorm.DB
```

--------------------------------

### POST /NameOpts

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Configuration structure for defining how numerological values are calculated from a name.

```APIDOC
## POST /NameOpts

### Description
Defines the options required to perform a numerological calculation on a name.

### Request Body
- **number_system** (NumberSystem) - Required - The numerological number system to use.
- **master_numbers** (array of int) - Optional - Master numbers that should not be reduced.
- **reduce_words** (boolean) - Optional - Determines if names are reduced independently before summing.
```

--------------------------------

### GetNumberSystem

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Retrieves a specific number system configuration by name.

```APIDOC
## GetNumberSystem

### Description
Returns the appropriate NumberSystem struct based on the provided name (e.g., 'Pythagorean', 'Chaldean').

### Parameters
#### Query Parameters
- **s** (string) - Required - The name of the number system.

### Response
#### Success Response (200)
- **Name** (string) - Name of the system.
- **NumberMapping** (map[int32]int) - Letter to value mapping.
- **ValidNumbers** (array[int]) - Accepted numbers in the system.
```

--------------------------------

### Marshal NumberSystem to JSON

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Custom JSON marshaling that returns only the name of the number system.

```go
func (ns NumberSystem) MarshalJSON() ([]byte, error)
```

--------------------------------

### Date Options Structure

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Defines options for date numerology calculations, including custom Master Numbers.

```go
type DateOpts struct {
	// MasterNumbers are two (or more) digit numbers that should not be reduced because they are
	// considered to have special numerological value. The most commonly considered master numbers
	// are repeating digits. ex 11, 22, 33, 44, 55
	MasterNumbers []int `json:"master_numbers"`
}
```

--------------------------------

### Variables

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Global variables including regular expressions for character validation and number system configurations.

```APIDOC
## Variables

### Acceptable Unknown Characters

```go
var AcceptableUnknownCharacters = regexp.MustCompile("[-\\s.]'")
```
AcceptableUnknownCharacters is a regexp that matches characters that should be considered acceptable in names. This includes dashes (Hernandez-Johnson), periods (Jr.), and white space characters. This is used before Marshaling to JSON. Replace this variable if a different set of AcceptableUnknownCharacters is needed.

### Chaldean Number System

```go
var Chaldean = NumberSystem{
	Name: "Chaldean",
	NumberMapping: map[int32]int{
		'a': 1, 'i': 1, 'j': 1, 'q': 1, 'y': 1,
		'b': 2, 'k': 2, 'r': 2,
		'c': 3, 'g': 3, 'l': 3, 's': 3,
		'd': 4, 'm': 4, 't': 4,
		'e': 5, 'h': 5, 'n': 5, 'x': 5,
		'u': 6, 'v': 6, 'w': 6,
		'o': 7, 'z': 7,
		'f': 8, 'p': 8,
		'0': 0, '1': 1, '2': 2, '3': 3, '4': 4,
		'5': 5, '6': 6, '7': 7, '8': 8, '9': 9,
		' ': 0, '.': 0, '-': 0,
	},
	ValidNumbers: []int{1, 2, 3, 4, 5, 6, 7, 8},
}
```
The conversion table for the Chaldean number system.

### Database Connection

```go
var DB *gorm.DB
```
DB holds the database connection used of name searches. Gorm is used which means that only SQLite, MySQL, and PostgreSQL are supported out-of-the-box. Variable is exposed in case someone wanted to hack on other database solutions for a project.

### Pythagorean Number System

```go
var Pythagorean = NumberSystem{
	Name: "Pythagorean",
	NumberMapping: map[int32]int{
		'a': 1, 'j': 1, 's': 1,
		'b': 2, 'k': 2, 't': 2,
		'c': 3, 'l': 3, 'u': 3,
		'd': 4, 'm': 4, 'v': 4,
		'e': 5, 'n': 5, 'w': 5,
		'f': 6, 'o': 6, 'x': 6,
		'g': 7, 'p': 7, 'y': 7,
		'h': 8, 'q': 8, 'z': 8,
		'i': 9, 'r': 9,
		'0': 0, '1': 1, '2': 2,
		'3': 3, '4': 4, '5': 5,
		'6': 6, '7': 7, '8': 8,
		'9': 9,
		' ': 0, '.': 0, '-': 0,
	},
	ValidNumbers: []int{1, 2, 3, 4, 5, 6, 7, 8, 9},
}
```
The conversion table for the Pythagorean number system.
```

--------------------------------

### Database Creation

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Function to create a new numerology database.

```APIDOC
## POST /websites/pkg_go_dev_github_com_landertome_numerologycalculator/CreateDatabase

### Description
Creates a new numerology database at the specified directory.

### Method
POST

### Endpoint
/websites/pkg_go_dev_github_com_landertome_numerologycalculator/CreateDatabase

### Parameters
#### Query Parameters
- **dsn** (string) - Required - The data source name for the database.
- **baseDir** (string) - Required - The base directory where the database will be created.

### Request Example
```json
{
  "dsn": "your_database_connection_string",
  "baseDir": "/path/to/database/directory"
}
```

### Response
#### Success Response (200)
- **message** (string) - Indicates successful database creation.

#### Response Example
```json
{
  "message": "Database created successfully."
}
```
```

--------------------------------

### Constants

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Constants for days of the week, sorting methods, and gender identification.

```APIDOC
## Constants

### Days of the Week

```go
const (
	Sunday = iota
	Monday
	Tuesday
	Wednesday
	Thursday
	Friday
	Saturday
)
```
Days of the week values for use in date searches. Values are similar to time.Weekday.

### Sorting Methods

```go
const (
	CommonSort   = "common"
	UncommonSort = "uncommon"
	RandomSort   = "random"
)
```
Constants that represent the name sorting methods.

### Gender Constants

```go
const (
	Male   = Gender('M')
	Female = Gender('F')
	Both   = Gender('B')
)
```
Gender constants for use when searching for names of a particular gender.
```

--------------------------------

### Define directory layout for database population

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator

Folder names within the base directory are used as table names in the database.

```text
baseDir\
  ├── table1\
  │     ├── file1.csv
  │     └── file2.csv
  └── table2\
        ├── file1.csv
        └── file2.csv
```

--------------------------------

### Result Structures

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Data structures for packaging numerological calculation results.

```APIDOC
## Result Structures

### Description
Structures that package key information from numerological calculations.

### Structures

#### `HiddenPassionResults`

- **Numbers** ([]int) - Slice of numbers with the highest or equally highest count.
- **MaxCount** (int) - The count of the highest number(s).

#### `KarmicLessonResults`

- **Numbers** ([]int) - Slice of numbers not found in the lookup (karmic lessons).
```

--------------------------------

### Search for dates with numerological criteria

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator

Uses DateSearchOpts to define search parameters like match numbers, days of the week, and search duration.

```go
package main

import "github.com/LanderTome/numerologyCalculator/numerology"

func main() {
	dt := numerology.NewDate(2021, 1, 1)
	masterNumbers := []int{11, 22, 33}
	date := numerology.Date(dt, masterNumbers)

	searchOpts := numerology.DateSearchOpts{
		Count:         10,
		Offset:        0,
		Match:         []int{3, 6},
		MonthsForward: 12,
		Dow:           []int{numerology.Friday, numerology.Saturday},
		LifePath:      false,
	}
	results, offset := date.Search(searchOpts)
}
```

--------------------------------

### Name Sorting Method Constants

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Constants for different name sorting methods. Use when specifying how names should be sorted.

```go
const (
	CommonSort   = "common"
	UncommonSort = "uncommon"
	RandomSort   = "random"
)
```

--------------------------------

### Day of the Week Constants

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Constants representing days of the week, similar to time.Weekday. Use for date searches.

```go
const (
	Sunday = iota
	Monday
	Tuesday
	Wednesday
	Thursday
	Friday
	Saturday
)
```

--------------------------------

### Gender Constants

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Constants for specifying gender. Use for filtering name searches by gender.

```go
const (
	Male   = Gender('M')
	Female = Gender('F')
	Both   = Gender('B')
)
```

--------------------------------

### Search Names with Numerological Criteria

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator

Use this function to search a database for names matching specific numerological properties. Configure search options like count, offset, database, dictionary, gender, and desired numerological values (full, vowels, consonants, etc.).

```go
package main

import "github.com/LanderTome/numerologyCalculator/numerology"

func main() {
	numberSystem := numerology.Pythagorean
	masterNumbers := []int{11, 22, 33}
	reduceWords := true
	name := numerology.Name("Jane ? Doe", numberSystem, masterNumbers, reduceWords)
	searchOpts := numerology.NameSearchOpts{
		Count:          10,
		Offset:         0,
		Seed:           0,
		Database:       "sqlite://test_names.db",
		Dictionary:     "usa_census",
		Gender:         numerology.Female,
		Sort:           numerology.CommonSort,
		Full:           []int{1, 8, -13},
		Vowels:         []int{4, 5, 6},
		Consonants:     []int{5},
		HiddenPassions: nil,
		KarmicLessons:  nil,
	}
	results, offset, err := name.Search(searchOpts)
}
```

--------------------------------

### NewDate Function

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

A wrapper function to create a time.Time object for date calculations. It defaults to midday UTC to prevent accidental timezone conversions.

```go
func NewDate(year, month, day int) (newDate time.Time)
```

--------------------------------

### Karmic Lesson Results Structure

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Packages the key information from the Numbers function, specifically listing numbers not found in the Lookup.

```go
type KarmicLessonResults struct {
	// Numbers is a slice of int of all the numbers that are not found in the Lookup.
	Numbers []int `json:"karmic_lessons"`
}
```

--------------------------------

### Unmarshal NumberSystem from JSON

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Custom JSON unmarshaling that converts a name string back into a NumberSystem struct.

```go
func (*NumberSystem) UnmarshalJSON(value []byte) error
```

--------------------------------

### Search for Names Based on Numerology

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Searches a name database for names that satisfy given numerological criteria. Returns matching names, an offset, and an error if any.

```go
func (n NameNumerology) Search(opts NameSearchOpts) (results []NameNumerology, offset int64, err error)
```

--------------------------------

### Calculate numerological properties

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator

Retrieve various numerological values from an initialized name object using provided methods and aliases.

```go
result := name.Full()
destiny := name.Destiny() // alias for name.Full()
expression := name.Expression() // alias for name.Full()

result := name.Vowels()
soulsUrge := name.SoulsUrge() // alias for name.Vowels()
heartsDesire := name.HeartsDesire() // alias for name.Vowels()

result := name.Consonants()
personality := name.Personality() // alias for name.Consonants()

hiddenPassions := name.HiddenPassions()
karmicLessons := name.KarmicLessons()
```

--------------------------------

### Debug Method

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Provides a string representation of the numerological conversion for debugging purposes.

```APIDOC
## func (NumerologicalResult) Debug

### Description
Returns a printable string providing a summary of the numerological conversion process.

### Response
- **debug** (string) - A formatted string showing the breakdown and reduction steps.
```

--------------------------------

### Define NameSearchOpts struct

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Defines the configuration options for searching numerological names, including filters for numerological values, sorting, and pagination.

```go
type NameSearchOpts struct {
	// Count is the number of results to return.
	Count int `json:"count,omitempty"`

	// Offset is used to page through the search results. Its main use is with an web service.
	Offset int `json:"offset,omitempty"`

	// Seed is used to generate random search results for names. Seed is necessary in order to page through
	// random results by maintaining the random order.
	Seed int64 `json:"seed,omitempty"`

	// Database is the DSN string that connects to the database that has the precalculated numerological names.
	Database string `json:"db,omitempty"`

	// Dictionary is the name of the database table to search.
	Dictionary string `json:"dictionary,omitempty"`

	// Gender is a filter to limit search results to names that are generally (m)ale, (f)emale, or (b)oth.
	Gender Gender `json:"gender,omitempty"`

	// Sort is the method of sorting used when return names. The options are "common", "uncommon", and "random".
	Sort string `json:"sort,omitempty"`

	// Full is the numerological numbers you want to search for that are calculated with all the letters of the given
	// name. Often referred to as "Destiny" or "Expression" number, Full was chosen in order to avoid favoring
	// one particular designation, and to make it clear what calculation is being performing.
	Full []int `json:"full,omitempty"`

	// Vowels is the numerological numbers you want to search for that are calculated with just the vowel letters of
	// the given name. Often referred to as "Soul's Urge" or "Heart's Desire" number, Vowels was chosen in order to
	// avoid favoring one particular designation, and to make it clear what calculation is being performing.
	//
	// This calculation is complicated by the fact that the letter "Y" sometimes acts like a vowel. Because the
	// database is precomputed, a consistent set rules need to be used in order to get consistent results. The
	// method used will generally be correct, but names with "Y" in them are probably the least reliable results.
	Vowels []int `json:"vowels,omitempty"`

	// Consonants is the numerological numbers you want to search for that are calculated with just the consonant
	// letters of the given name. Sometimes referred to as "Personality", Consonants was chosen in order to avoid
	// favoring one particular designation, and to make it clear what calculation is being performing.
	//
	// This calculation is complicated by the fact that the letter "Y" sometimes acts like a vowel. Because the
	// database is precomputed, a consistent set rules need to be used in order to get consistent results. The
	// method used will generally be correct, but names with "Y" in them are probably the least reliable results.
	Consonants []int `json:"consonants,omitempty"`

	// HiddenPassions contains the numerological number(s) that occur the most frequently in the name.
	// Positive and  negative numbers can be used. Positive numbers are inclusive; they ensure that
	// number will exist in the final grouping. Negative numbers are exclusive, they exclude that number from
	// existing in the final grouping.
	HiddenPassions []int `json:"hidden_passions,omitempty"`

	// KarmicLessons contains the numerological number(s) that do not appear at all in the name.
	// Positive and  negative numbers can be used. Positive numbers are inclusive; they ensure that
	// number will exist in the final grouping. Negative numbers are exclusive, they exclude that number from
	// existing in the final grouping.
	KarmicLessons []int `json:"karmic_lessons,omitempty"`
}
```

--------------------------------

### Pythagorean Number System Mapping

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Defines the Pythagorean number system's character-to-value mapping and valid number ranges. Used for numerological calculations.

```go
var Pythagorean = NumberSystem{
	Name: "Pythagorean",
	NumberMapping: map[int32]int{
		'a': 1, 'j': 1, 's': 1,
		'b': 2, 'k': 2, 't': 2,
		'c': 3, 'l': 3, 'u': 3,
		'd': 4, 'm': 4, 'v': 4,
		'e': 5, 'n': 5, 'w': 5,
		'f': 6, 'o': 6, 'x': 6,
		'g': 7, 'p': 7, 'y': 7,
		'h': 8, 'q': 8, 'z': 8,
		'i': 9, 'r': 9,
		'0': 0, '1': 1, '2': 2,
		'3': 3, '4': 4, '5': 5,
		'6': 6, '7': 7, '8': 8,
		'9': 9,
		' ': 0, '.': 0, '-': 0,
	},
	ValidNumbers: []int{1, 2, 3, 4, 5, 6, 7, 8, 9},
}
```

--------------------------------

### Marshal Gender to JSON

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Custom JSON marshaling for the Gender type, creating a JSON string representation.

```go
func (g Gender) MarshalJSON() ([]byte, error)
```

--------------------------------

### Date Search Options Structure

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Specifies criteria for searching numerological dates, including count, match values, time frame, and day of the week.

```go
type DateSearchOpts struct {
	// Count is the number of results to return.
	Count int `json:"count,omitempty"`

	// Offset is used to page through the search results. Its main use is with an web service.
	Offset int `json:"offset,omitempty"`

	// Match is a slice of ints that are the numerological values that we want to find.
	Match []int `json:"match,omitempty"`

	// MonthsForward is the number of months in which to search. Usually one is trying to find a date within
	// some reasonable time frame; like for a wedding or event.
	MonthsForward int `json:"months_forward,omitempty"`

	// Dow, or Days of the Week, limits the results to ones that fall on certain days.
	// 0=Sun 1=Mon 2=Tue 3=Wed 4=Thu 5=Fri 6=Sat
	Dow []int `json:"dow,omitempty"`

	// LifePath is generally used with ones date of birth. If false, then Master Numbers are ignored
	// for the calculation.
	LifePath bool `json:"life_path"`
}
```

--------------------------------

### Breakdown Struct

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Represents the numerological conversion of a name, including the final value, reduction steps, and individual letter values.

```go
type Breakdown struct {
	// Value contains the reduced numerological value of the name.
	Value int `json:"value"`

	// ReduceSteps contains the conversion at each step until the final number.
	ReduceSteps []int `json:"reduce_steps"`

	// LetterValues shows the numerological value of each letter in the name.
	LetterValues []letterValue `json:"letter_values"`
}
```

--------------------------------

### Calculate Numerological Numbers for Multiple Names

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Calculates various numerological numbers from a list of names. Supports different number systems (Pythagorean, Chaldean) and reduction methods.

```go
func Names(names []string, numberSystem NumberSystem, masterNumbers []int, reduceWords bool) (results []NameNumerology)
```

--------------------------------

### Count Numerological Values in a Name

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Returns a map of each numerological value and its frequency within the name.

```go
func (n *NameNumerology) Counts() (counts map[int32]int)
```

--------------------------------

### Define NumberSystem struct

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Defines the structure for mapping characters to numerological values and identifying valid numbers within a system.

```go
type NumberSystem struct {
	// Name of the NumberSystem that is used to translate to and from JSON.
	Name string

	// NumberMapping is a map of letters and their corresponding value.
	NumberMapping map[int32]int

	// ValidNumbers shows all the numbers that the number system accepts. The Chaldean number system,
	// in particular, does not use the number 9 in conversions.
	ValidNumbers []int
}
```

--------------------------------

### Define CSV structure for name data

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator

CSV files must contain name, gender, and popularity columns without headers.

```csv
Mary,F,100
Michael,M,98
John,M,95
Susan,F,94
```

--------------------------------

### DateNumerology Struct

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Stores information required for calculating numerological values of dates. Includes the date itself and options for date calculations and searches.

```go
type DateNumerology struct {
	// Date is either the date to use to calculate numerological values or the date
	// used to start searches.
	Date time.Time

	// Pointers are used so that these options can be shared amongst a number of
	// DateNumerology objects.
	*DateOpts
	*DateSearchOpts
}
```

--------------------------------

### Calculate Numerological Numbers for a Single Name

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Calculates various numerological numbers from a given name. Supports different number systems (Pythagorean, Chaldean) and reduction methods.

```go
func Name(name string, numberSystem NumberSystem, masterNumbers []int, reduceWords bool) (result NameNumerology)
```

--------------------------------

### Types

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Data structures for representing numerological breakdowns and date-related numerology.

```APIDOC
## Types

### Breakdown

```go
type Breakdown struct {
	// Value contains the reduced numerological value of the name.
	Value int `json:"value"`

	// ReduceSteps contains the conversion at each step until the final number.
	ReduceSteps []int `json:"reduce_steps"`

	// LetterValues shows the numerological value of each letter in the name.
	LetterValues []letterValue `json:"letter_values"`
}
```

Breakdown contains information from the conversion of a name to its numerological equivalent.

### DateNumerology

```go
type DateNumerology struct {
	// Date is either the date to use to calculate numerological values or the date
	// used to start searches.
	Date time.Time

	// Pointers are used so that these options can be shared amongst a number of
	// DateNumerology objects.
	*DateOpts
	*DateSearchOpts
}
```

DateNumerology stores required information to calculate the numerological values of dates.
```

--------------------------------

### Search for Numerological Dates

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Searches for dates that meet specific numerological criteria. Use DateSearchOpts to define search parameters. The offset indicates the next batch of results.

```go
func (d DateNumerology) Search(opts DateSearchOpts) (searchResults []DateNumerology, offset int64)
```

--------------------------------

### Date Numerology Functions

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Functions for creating and calculating numerology for dates.

```APIDOC
## POST /websites/pkg_go_dev_github_com_landertome_numerologycalculator/NewDate

### Description
Creates a new time.Time object from year, month, and day.

### Method
POST

### Endpoint
/websites/pkg_go_dev_github_com_landertome_numerologycalculator/NewDate

### Parameters
#### Request Body
- **year** (int) - Required - The year.
- **month** (int) - Required - The month.
- **day** (int) - Required - The day.

### Request Example
```json
{
  "year": 2023,
  "month": 10,
  "day": 26
}
```

### Response
#### Success Response (200)
- **newDate** (time.Time) - The created time.Time object.

#### Response Example
```json
{
  "newDate": "2023-10-26T00:00:00Z"
}
```
```

```APIDOC
## POST /websites/pkg_go_dev_github_com_landertome_numerologycalculator/Date

### Description
Calculates various numerological numbers for a given date.

### Method
POST

### Endpoint
/websites/pkg_go_dev_github_com_landertome_numerologycalculator/Date

### Parameters
#### Request Body
- **date** (time.Time) - Required - The date for which to calculate numerology.
- **masterNumbers** ([]int) - Optional - A list of custom master numbers to consider.

### Request Example
```json
{
  "date": "2023-10-26T00:00:00Z",
  "masterNumbers": [11, 22]
}
```

### Response
#### Success Response (200)
- **result** (DateNumerology) - The calculated numerology results for the date.

#### Response Example
```json
{
  "result": {
    "lifePath": {
      "number": 8,
      "summary": "Strength and authority."
    },
    "event": {
      "number": 5,
      "summary": "Freedom and change."
    }
  }
}
```
```

```APIDOC
## POST /websites/pkg_go_dev_github_com_landertome_numerologycalculator/Dates

### Description
Calculates numerology for a list of dates.

### Method
POST

### Endpoint
/websites/pkg_go_dev_github_com_landertome_numerologycalculator/Dates

### Parameters
#### Request Body
- **dates** ([]time.Time) - Required - A list of dates for which to calculate numerology.
- **masterNumbers** ([]int) - Optional - A list of custom master numbers to consider.

### Request Example
```json
{
  "dates": ["2023-10-26T00:00:00Z", "2023-11-15T00:00:00Z"],
  "masterNumbers": [11]
}
```

### Response
#### Success Response (200)
- **results** ([]DateNumerology) - A list of calculated numerology results for each date.

#### Response Example
```json
{
  "results": [
    {
      "lifePath": {
        "number": 8,
        "summary": "Strength and authority."
      }
    },
    {
      "lifePath": {
        "number": 6,
        "summary": "Harmony and responsibility."
      }
    }
  ]
}
```
```

--------------------------------

### Calculate Expression Numerology

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Calculates the Expression number, which is an alias for the Full() calculation.

```go
func (n NameNumerology) Expression() (expression NumerologicalResult)
```

--------------------------------

### Calculate Date Numerology

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Calculates numerological values for a single date. Use this for general date numerology.

```go
func Date(date time.Time, masterNumbers []int) (result DateNumerology)
```

--------------------------------

### Gender Type and Methods

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Custom Gender type with JSON marshaling and unmarshaling capabilities.

```APIDOC
## Gender Type and Methods

### Description
Custom `Gender` type for handling JSON marshaling and unmarshaling.

### Methods

#### `MarshalJSON() ([]byte, error)`

Creates a JSON string representation for `Gender`.

#### `UnmarshalJSON(value []byte) error`

Converts a JSON string ('M', 'F', 'B') to a `Gender` rune. Defaults to 'B' (Both) for invalid inputs.
```

--------------------------------

### NameSearchOpts Structure

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Defines the configuration options for performing numerological name searches.

```APIDOC
## NameSearchOpts

### Description
Represents the search criteria for querying numerological names from a database.

### Request Body
- **count** (int) - Optional - Number of results to return.
- **offset** (int) - Optional - Used for pagination.
- **seed** (int64) - Optional - Seed for randomizing results.
- **db** (string) - Optional - DSN string for database connection.
- **dictionary** (string) - Optional - Name of the database table to search.
- **gender** (Gender) - Optional - Filter by gender (m, f, b).
- **sort** (string) - Optional - Sorting method (common, uncommon, random).
- **full** (array[int]) - Optional - Destiny/Expression numbers.
- **vowels** (array[int]) - Optional - Soul's Urge/Heart's Desire numbers.
- **consonants** (array[int]) - Optional - Personality numbers.
- **hidden_passions** (array[int]) - Optional - Most frequent numbers in the name.
- **karmic_lessons** (array[int]) - Optional - Numbers that do not appear in the name.
```

--------------------------------

### Chaldean Number System Mapping

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Defines the Chaldean number system's character-to-value mapping and valid number ranges. Used for numerological calculations.

```go
var Chaldean = NumberSystem{
	Name: "Chaldean",
	NumberMapping: map[int32]int{
		'a': 1, 'i': 1, 'j': 1, 'q': 1, 'y': 1,
		'b': 2, 'k': 2, 'r': 2,
		'c': 3, 'g': 3, 'l': 3, 's': 3,
		'd': 4, 'm': 4, 't': 4,
		'e': 5, 'h': 5, 'n': 5, 'x': 5,
		'u': 6, 'v': 6, 'w': 6,
		'o': 7, 'z': 7,
		'f': 8, 'p': 8,
		'0': 0, '1': 1, '2': 2, '3': 3, '4': 4,
		'5': 5, '6': 6, '7': 7, '8': 8, '9': 9,
		' ': 0, '.': 0, '-': 0,
	},
	ValidNumbers: []int{1, 2, 3, 4, 5, 6, 7, 8},
}
```

--------------------------------

### Date and Name Search

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Functions for searching dates and names based on numerological criteria.

```APIDOC
## POST /websites/pkg_go_dev_github_com_landertome_numerologycalculator/DateNumerology/Search

### Description
Searches for dates that satisfy specific numerological criteria.

### Method
POST

### Endpoint
/websites/pkg_go_dev_github_com_landertome_numerologycalculator/DateNumerology/Search

### Parameters
#### Request Body
- **dateNumerology** (DateNumerology) - Required - The DateNumerology object containing search criteria.
- **opts** (DateSearchOpts) - Required - Options for the date search.

### Request Example
```json
{
  "dateNumerology": {
    "lifePath": {"number": 8}
  },
  "opts": {
    "startDate": "2023-01-01",
    "endDate": "2023-12-31"
  }
}
```

### Response
#### Success Response (200)
- **searchResults** ([]DateNumerology) - A list of DateNumerology objects that match the criteria.
- **offset** (int64) - The offset for pagination.

#### Response Example
```json
{
  "searchResults": [
    {
      "date": "2023-03-15T00:00:00Z",
      "lifePath": {"number": 8, "summary": "Strength and authority."}
    }
  ],
  "offset": 0
}
```
```

```APIDOC
## POST /websites/pkg_go_dev_github_com_landertome_numerologycalculator/NameNumerology/Search

### Description
Searches for names that satisfy specific numerological criteria.

### Method
POST

### Endpoint
/websites/pkg_go_dev_github_com_landertome_numerologycalculator/NameNumerology/Search

### Parameters
#### Request Body
- **nameNumerology** (NameNumerology) - Required - The NameNumerology object containing search criteria.
- **opts** (NameSearchOpts) - Required - Options for the name search.

### Request Example
```json
{
  "nameNumerology": {
    "destiny": {"number": 7}
  },
  "opts": {
    "limit": 10
  }
}
```

### Response
#### Success Response (200)
- **results** ([]NameNumerology) - A list of NameNumerology objects that match the criteria.
- **offset** (int64) - The offset for pagination.
- **err** (error) - An error object if the search failed.

#### Response Example
```json
{
  "results": [
    {
      "name": "Sophia",
      "destiny": {"number": 7, "summary": "Wisdom and introspection."}
    }
  ],
  "offset": 0,
  "err": null
}
```
```

--------------------------------

### Define NumerologicalResult Struct

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Defines the structure for storing numerological calculation results, including the reduced value, steps taken, and individual breakdowns.

```go
type NumerologicalResult struct {
	// Value contains the reduced numerological value of the name.
	Value int `json:"value"`

	// ReduceSteps contains the conversion at each step until the final number.
	ReduceSteps []int `json:"reduce_steps"`

	// Breakdown contains each individual Breakdown that contributed to the final calculation.
	Breakdown []Breakdown `json:"breakdown"`
}
```

--------------------------------

### Gender Custom Type

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

A custom rune type for gender, used to customize JSON marshaling and unmarshaling.

```go
type Gender rune
```

--------------------------------

### Acceptable Unknown Characters Regex

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

A regular expression to match acceptable characters in names, such as hyphens, periods, and spaces. Used before JSON marshaling. Replace if different characters are needed.

```go
var AcceptableUnknownCharacters = regexp.MustCompile("[-\\s.]'")
```

--------------------------------

### Calculate Multiple Dates Numerology

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

Calculates numerological values for a slice of dates. Useful for processing multiple dates at once.

```go
func Dates(dates []time.Time, masterNumbers []int) (results []DateNumerology)
```

--------------------------------

### Define NameNumerology Struct

Source: https://pkg.go.dev/github.com/LanderTome/numerologyCalculator/numerology

The NameNumerology struct stores the name and configuration for numerological calculations.

```go
type NameNumerology struct {
	Name string
	*NameOpts
	*NameSearchOpts
	// contains filtered or unexported fields
}
```
Tokens:
Raw