add some new SI prefixes that was standardized in November (ronna, quetta), source https://www.bipm.org/documents/20126/64811223/Resolutions-2022.pdf page 'Resolution 3'

Author: martinlindhe

datasize.go

@@ -6,25 +6,29 @@ type Datasize Unit
 // ...
 const (
 	// base 10 (SI prefixes)
-	Bit      Datasize = 1e0
-	Kilobit           = Bit * 1e3
-	Megabit           = Bit * 1e6
-	Gigabit           = Bit * 1e9
-	Terabit           = Bit * 1e12
-	Petabit           = Bit * 1e15
-	Exabit            = Bit * 1e18
-	Zettabit          = Bit * 1e21
-	Yottabit          = Bit * 1e24
-
-	Byte      = Bit * 8
-	Kilobyte  = Byte * 1e3
-	Megabyte  = Byte * 1e6
-	Gigabyte  = Byte * 1e9
-	Terabyte  = Byte * 1e12
-	Petabyte  = Byte * 1e15
-	Exabyte   = Byte * 1e18
-	Zettabyte = Byte * 1e21
-	Yottabyte = Byte * 1e24
+	Bit       Datasize = 1e0
+	Kilobit            = Bit * 1e3
+	Megabit            = Bit * 1e6
+	Gigabit            = Bit * 1e9
+	Terabit            = Bit * 1e12
+	Petabit            = Bit * 1e15
+	Exabit             = Bit * 1e18
+	Zettabit           = Bit * 1e21
+	Yottabit           = Bit * 1e24
+	Ronnabit           = Bit * 1e27
+	Quettabit          = Bit * 1e30
+
+	Byte       = Bit * 8
+	Kilobyte   = Byte * 1e3
+	Megabyte   = Byte * 1e6
+	Gigabyte   = Byte * 1e9
+	Terabyte   = Byte * 1e12
+	Petabyte   = Byte * 1e15
+	Exabyte    = Byte * 1e18
+	Zettabyte  = Byte * 1e21
+	Yottabyte  = Byte * 1e24
+	Ronnabyte  = Byte * 1e27
+	Quettabyte = Byte * 1e30
 
 	// base 2 (IEC prefixes)
 	Kibibit = Bit * 1024
@@ -91,6 +95,16 @@ func (b Datasize) Yottabits() float64 {
 	return float64(b / Yottabit)
 }
 
+// Ronnabits returns the datasize in Rbit
+func (b Datasize) Ronnabits() float64 {
+	return float64(b / Ronnabit)
+}
+
+// Quettabits returns the datasize in Qbit
+func (b Datasize) Quettabits() float64 {
+	return float64(b / Quettabit)
+}
+
 // Bytes returns the datasize in B
 func (b Datasize) Bytes() float64 {
 	return float64(b / Byte)
@@ -136,6 +150,16 @@ func (b Datasize) Yottabytes() float64 {
 	return float64(b / Yottabyte)
 }
 
+// Ronnabytes returns the datasize in RB
+func (b Datasize) Ronnabytes() float64 {
+	return float64(b / Ronnabyte)
+}
+
+// Quettabytes returns the datasize in RB
+func (b Datasize) Quettabytes() float64 {
+	return float64(b / Quettabyte)
+}
+
 // Kibibits returns the datasize in Kibit
 func (b Datasize) Kibibits() float64 {
 	return float64(b / Kibibit)

length.go

@@ -28,6 +28,8 @@ const (
 	Exameter                = Meter * 1e18
 	Zettameter              = Meter * 1e21
 	Yottameter              = Meter * 1e24
+	Ronnameter              = Meter * 1e27
+	Quettameter             = Meter * 1e30
 
 	// US
 	Inch    = Meter * 0.0254
@@ -164,6 +166,16 @@ func (l Length) Yottameters() float64 {
 	return float64(l / Yottameter)
 }
 
+// Ronnameters returns the length in in Rm
+func (l Length) Ronnameters() float64 {
+	return float64(l / Ronnameter)
+}
+
+// Quettameters returns the length in in Qm
+func (l Length) Quettameters() float64 {
+	return float64(l / Quettameter)
+}
+
 // Inches returns the length in in
 func (l Length) Inches() float64 {
 	return float64(l / Inch)

mass.go

@@ -6,27 +6,29 @@ type Mass Unit
 // ...
 const (
 	// SI
-	Yoctogram      = Gram * 1e-24
-	Zeptogram      = Gram * 1e-21
-	Attogram       = Gram * 1e-18
-	Femtogram      = Gram * 1e-15
-	Picogram       = Gram * 1e-12
-	Nanogram       = Gram * 1e-9
-	Microgram      = Gram * 1e-6
-	Milligram      = Gram * 1e-3
-	Centigram      = Gram * 1e-2
-	Decigram       = Gram * 1e-1
-	Gram           = Kilogram * 1e-3
-	Decagram       = Gram * 1e1
-	Hectogram      = Gram * 1e2
-	Kilogram  Mass = 1e0
-	Megagram       = Gram * 1e6
-	Gigagram       = Gram * 1e9
-	Teragram       = Gram * 1e12
-	Petagram       = Gram * 1e15
-	Exagram        = Gram * 1e18
-	Zettagram      = Gram * 1e21
-	Yottagram      = Gram * 1e24
+	Yoctogram       = Gram * 1e-24
+	Zeptogram       = Gram * 1e-21
+	Attogram        = Gram * 1e-18
+	Femtogram       = Gram * 1e-15
+	Picogram        = Gram * 1e-12
+	Nanogram        = Gram * 1e-9
+	Microgram       = Gram * 1e-6
+	Milligram       = Gram * 1e-3
+	Centigram       = Gram * 1e-2
+	Decigram        = Gram * 1e-1
+	Gram            = Kilogram * 1e-3
+	Decagram        = Gram * 1e1
+	Hectogram       = Gram * 1e2
+	Kilogram   Mass = 1e0
+	Megagram        = Gram * 1e6
+	Gigagram        = Gram * 1e9
+	Teragram        = Gram * 1e12
+	Petagram        = Gram * 1e15
+	Exagram         = Gram * 1e18
+	Zettagram       = Gram * 1e21
+	Yottagram       = Gram * 1e24
+	Ronnagram       = Gram * 1e27
+	Quettagram      = Gram * 1e30
 
 	// non-SI
 	Tonne     = Megagram
@@ -163,6 +165,16 @@ func (m Mass) Yottagrams() float64 {
 	return float64(m / Yottagram)
 }
 
+// Ronnagrams returns the mass in Rg
+func (m Mass) Ronnagrams() float64 {
+	return float64(m / Ronnagram)
+}
+
+// Quettagrams returns the mass in Qg
+func (m Mass) Quettagrams() float64 {
+	return float64(m / Quettagram)
+}
+
 // Tonnes returns the mass in t
 func (m Mass) Tonnes() float64 {
 	return float64(m / Tonne)