radboy 0.0.714__py3-none-any.whl → 0.0.716__py3-none-any.whl

radboy/preloader/preloader_func.py

@@ -28,6 +28,388 @@ import decimal
 from decimal import localcontext,Decimal
 unit_registry=pint.UnitRegistry()
 import math
+
+def volume():
+	with localcontext() as ctx:
+		ctx.prec=int(db.detectGetOrSet("lsbld ROUNDTO default",4,setValue=False,literal=True))
+		#print(f"{Fore.light_green}Precision {ctx.prec}{Fore.light_yellow}")
+		height=Prompt.__init2__(None,func=FormBuilderMkText,ptext=f"{Fore.light_green}Precision {ctx.prec}{Fore.light_yellow} height?: ",helpText="height=1",data="dec.dec")
+		if height is None:
+			return
+		elif height in ['d',]:
+			height=Decimal('1')
+		
+		width=Prompt.__init2__(None,func=FormBuilderMkText,ptext=f"{Fore.light_green}Precision {ctx.prec}{Fore.light_yellow} width?: ",helpText="width=1 ",data="dec.dec")
+		if width is None:
+			return
+		elif width in ['d',]:
+			width=Decimal('1')
+	
+
+
+		length=Prompt.__init2__(None,func=FormBuilderMkText,ptext=f"{Fore.light_green}Precision {ctx.prec}{Fore.light_yellow} length?: ",helpText="length=1",data="dec.dec")
+		if length is None:
+			return
+		elif length in ['d',]:
+			length=Decimal('1')
+
+		return length*width*height
+
+def volume_pint():
+	with localcontext() as ctx:
+		ctx.prec=int(db.detectGetOrSet("lsbld ROUNDTO default",4,setValue=False,literal=True))
+		height=Prompt.__init2__(None,func=FormBuilderMkText,ptext=f"{Fore.light_green}Precision {ctx.prec}{Fore.light_yellow} height?: ",helpText="height=1",data="string")
+		if height is None:
+			return
+		elif height in ['d',]:
+			height='1'
+		
+		width=Prompt.__init2__(None,func=FormBuilderMkText,ptext=f"{Fore.light_green}Precision {ctx.prec}{Fore.light_yellow} width?: ",helpText="width=1 ",data="string")
+		if width is None:
+			return
+		elif width in ['d',]:
+			width='1'
+		
+
+
+		length=Prompt.__init2__(None,func=FormBuilderMkText,ptext=f"{Fore.light_green}Precision {ctx.prec}{Fore.light_yellow} length?: ",helpText="length=1",data="string")
+		if length is None:
+			return
+		elif length in ['d',]:
+			length='1'
+
+		return unit_registry.Quantity(length)*unit_registry.Quantity(width)*unit_registry.Quantity(height)
+
+def inductance_pint():
+	with localcontext() as ctx:
+		ctx.prec=int(db.detectGetOrSet("lsbld ROUNDTO default",4,setValue=False,literal=True))
+		relative_permeability=Prompt.__init2__(None,func=FormBuilderMkText,ptext=f"{Fore.light_green}Precision {ctx.prec}{Fore.light_yellow} relative_permeability?: ",helpText="relative_permeability(air)=1",data="string")
+		if relative_permeability is None:
+			return
+		elif relative_permeability in ['d',]:
+			relative_permeability='1'
+		relative_permeability=float(relative_permeability)
+
+		turns_of_wire_on_coil=Prompt.__init2__(None,func=FormBuilderMkText,ptext=f"{Fore.light_green}Precision {ctx.prec}{Fore.light_yellow} turns_of_wire_on_coil?: ",helpText="turns_of_wire_on_coil=1",data="string")
+		if turns_of_wire_on_coil is None:
+			return
+		elif turns_of_wire_on_coil in ['d',]:
+			turns_of_wire_on_coil='1'
+		turns_of_wire_on_coil=int(turns_of_wire_on_coil)
+
+		#convert to meters
+		core_cross_sectional_area_meters=Prompt.__init2__(None,func=FormBuilderMkText,ptext=f"{Fore.light_green}Precision {ctx.prec}{Fore.light_yellow} core_cross_sectional_area_meters?: ",helpText="core_cross_sectional_area_meters=1",data="string")
+		if core_cross_sectional_area_meters is None:
+			return
+		elif core_cross_sectional_area_meters in ['d',]:
+			core_cross_sectional_area_meters='1m'
+		try:
+			core_cross_sectional_area_meters=unit_registry.Quantity(core_cross_sectional_area_meters).to("meters")
+		except Exception as e:
+			print(e,"defaulting to meters")
+			core_cross_sectional_area_meters=unit_registry.Quantity(f"{core_cross_sectional_area_meters} meters")
+
+		length_of_coil_meters=Prompt.__init2__(None,func=FormBuilderMkText,ptext=f"{Fore.light_green}Precision {ctx.prec}{Fore.light_yellow} length_of_coil_meters?: ",helpText="length_of_coil_meters=1",data="string")
+		if length_of_coil_meters is None:
+			return
+		elif length_of_coil_meters in ['d',]:
+			length_of_coil_meters='1m'
+		try:
+			length_of_coil_meters=unit_registry.Quantity(length_of_coil_meters).to('meters')
+		except Exception as e:
+			print(e,"defaulting to meters")
+			length_of_coil_meters=unit_registry.Quantity(f"{length_of_coil_meters} meters")
+		
+		numerator=((turns_of_wire_on_coil**2)*core_cross_sectional_area_meters)
+		f=relative_permeability*(numerator/length_of_coil_meters)*1.26e-6
+		f=unit_registry.Quantity(f"{f.magnitude} H")
+		return f
+
+def resonant_inductance():
+	with localcontext() as ctx:
+		ctx.prec=int(db.detectGetOrSet("lsbld ROUNDTO default",4,setValue=False,literal=True))
+		hertz=1e9
+		while True:
+			try:
+				hertz=Control(func=FormBuilderMkText,ptext=f"{Fore.light_green}Precision {ctx.prec}{Fore.light_yellow} frequency in hertz[530 kilohertz]? ",helpText="frequency in hertz",data="string")
+				if hertz is None:
+					return
+				elif hertz in ['d','']:
+					hertz="530 megahertz"
+				print(hertz)
+				x=unit_registry.Quantity(hertz)
+				if x:
+					hertz=x.to("hertz")
+				else:
+					hertz=1e6
+				break
+			except Exception as e:
+				print(e)
+
+		
+		while True:
+			try:
+				capacitance=Control(func=FormBuilderMkText,ptext=f"{Fore.light_green}Precision {ctx.prec}{Fore.light_yellow} capacitance[365 picofarads]? ",helpText="capacitance in farads",data="string")
+				if capacitance is None:
+					return
+				elif capacitance in ['d',]:
+					capacitance="365 picofarads"
+				x=unit_registry.Quantity(capacitance)
+				if x:
+					x=x.to("farads")
+				farads=x.magnitude
+				break
+			except Exception as e:
+				print(e)
+
+		inductance=1/(decc(4*math.pi**2)*decc(hertz.magnitude**2,cf=13)*decc(farads,cf=13))
+
+		L=unit_registry.Quantity(inductance,"henry")
+		return L
+
+def air_coil_cap():
+	with localcontext() as ctx:
+		ctx.prec=int(db.detectGetOrSet("lsbld ROUNDTO default",4,setValue=False,literal=True))
+		'''C = 1 / (4π²f²L)'''
+		while True:
+			try:
+				frequency=Control(func=FormBuilderMkText,ptext=f"{Fore.light_green}Precision {ctx.prec}{Fore.light_yellow} frequency? ",helpText="frequency",data="string")
+				if frequency is None:
+					return
+				elif frequency in ['d',]:
+					frequency="1410 kilohertz"
+				x=unit_registry.Quantity(frequency)
+				if x:
+					x=x.to("hertz")
+				frequency=decc(x.magnitude**2)
+				break
+			except Exception as e:
+				print(e)
+		
+		while True:
+			try:
+				inductance=Control(func=FormBuilderMkText,ptext=f"{Fore.light_green}Precision {ctx.prec}{Fore.light_yellow} inductance(356 microhenry): ",helpText="coil inductance",data="string")
+				if inductance is None:
+					return
+				elif inductance in ['d',]:
+					inductance="356 microhenry"
+				x=unit_registry.Quantity(inductance)
+				if x:
+					x=x.to("henry")
+				inductance=decc(x.magnitude,cf=20)
+				break
+			except Exception as e:
+				print(e)
+		
+
+		
+		farads=1/(inductance*frequency*decc(4*math.pi**2))
+		return unit_registry.Quantity(farads,"farad")
+
+def air_coil():
+	with localcontext() as ctx:
+		ctx.prec=int(db.detectGetOrSet("lsbld ROUNDTO default",4,setValue=False,literal=True))
+		'''
+		The formula for inductance - using toilet rolls, PVC pipe etc. can be well approximated by:
+
+
+		                  0.394 * r2 * N2
+		Inductance L = ________________
+		                 ( 9 *r ) + ( 10 * Len)
+		Here:
+		N = number of turns
+		r = radius of the coil i.e. form diameter (in cm.) divided by 2
+		Len = length of the coil - again in cm.
+		L = inductance in uH.
+		* = multiply by
+		'''
+		while True:
+			try:
+				diameter=Control(func=FormBuilderMkText,ptext=f"{Fore.light_green}Precision {ctx.prec}{Fore.light_yellow} diameter in cm [2 cm]? ",helpText="diamater of coil",data="string")
+				if diameter is None:
+					return
+				elif diameter in ['d',]:
+					diameter="2 cm"
+				x=unit_registry.Quantity(diameter)
+				if x:
+					x=x.to("centimeter")
+				diameter=x.magnitude
+				break
+			except Exception as e:
+				print(e)
+		radius=decc(diameter/2)
+		while True:
+			try:
+				length=Control(func=FormBuilderMkText,ptext=f"{Fore.light_green}Precision {ctx.prec}{Fore.light_yellow} length in cm [2 cm]? ",helpText="length of coil",data="string")
+				if length is None:
+					return
+				elif length in ['d',]:
+					length="2 cm"
+				x=unit_registry.Quantity(length)
+				if x:
+					x=x.to("centimeter")
+				length=x.magnitude
+				break
+			except Exception as e:
+				print(e)
+		while True:
+			try:
+				turns=Control(func=FormBuilderMkText,ptext=f"{Fore.light_green}Precision {ctx.prec}{Fore.light_yellow} number of turns? ",helpText="turns of wire",data="integer")
+				if turns is None:
+					return
+				elif turns in ['d',]:
+					turns=1
+				LTop=decc(0.394)*decc(radius**2)*decc(turns**2)
+				LBottom=(decc(9)*radius)+decc(length*10)
+				L=LTop/LBottom
+				print(pint.Quantity(L,'microhenry'))
+				different_turns=Control(func=FormBuilderMkText,ptext=f"{Fore.light_green}Precision {ctx.prec}{Fore.light_yellow} use a different number of turns?",helpText="yes or no",data="boolean")
+				if different_turns is None:
+					return
+				elif different_turns in ['d',True]:
+					continue
+				break
+			except Exception as e:
+				print(e)
+
+		
+		return pint.Quantity(L,'microhenry')
+
+def circumference_diameter():
+	with localcontext() as ctx:
+		ctx.prec=int(db.detectGetOrSet("lsbld ROUNDTO default",4,setValue=False,literal=True))
+		radius=0
+		while True:
+			try:
+				diameter=Control(func=FormBuilderMkText,ptext=f"{Fore.light_green}Precision {ctx.prec}{Fore.light_yellow} diameter unit[4 cm]? ",helpText="diamater with unit",data="string")
+				if diameter is None:
+					return
+				elif diameter in ['d',]:
+					diameter="4 cm"
+				x=unit_registry.Quantity(diameter)
+				radius=pint.Quantity(decc(x.magnitude/2),x.units)
+				break
+			except Exception as e:
+				print(e)
+		if isinstance(radius,pint.registry.Quantity):
+			result=decc(2*math.pi)*decc(radius.magnitude)
+
+			return pint.Quantity(result,radius.units)
+		else:
+			return
+
+def circumference_radius():
+	with localcontext() as ctx:
+		ctx.prec=int(db.detectGetOrSet("lsbld ROUNDTO default",4,setValue=False,literal=True))
+		radius=0
+		while True:
+			try:
+				diameter=Control(func=FormBuilderMkText,ptext=f"{Fore.light_green}Precision {ctx.prec}{Fore.light_yellow} radius unit[2 cm]? ",helpText="radius with unit",data="string")
+				if diameter is None:
+					return
+				elif diameter in ['d',]:
+					diameter="2 cm"
+				x=unit_registry.Quantity(diameter)
+				radius=pint.Quantity(decc(x.magnitude),x.units)
+				break
+			except Exception as e:
+				print(e)
+		if isinstance(radius,pint.registry.Quantity):
+			result=decc(2*math.pi)*decc(radius.magnitude)
+
+			return pint.Quantity(result,radius.units)
+		else:
+			return
+
+def area_of_circle_radius():
+	with localcontext() as ctx:
+		ctx.prec=int(db.detectGetOrSet("lsbld ROUNDTO default",4,setValue=False,literal=True))
+		'''
+	A = πr²
+		'''
+		radius=0
+		while True:
+			try:
+				diameter=Control(func=FormBuilderMkText,ptext=f"{Fore.light_green}Precision {ctx.prec}{Fore.light_yellow} radius unit[2 cm]? ",helpText="radius with unit",data="string")
+				if diameter is None:
+					return
+				elif diameter in ['d',]:
+					diameter="2 cm"
+				x=unit_registry.Quantity(diameter)
+				radius=pint.Quantity(decc(x.magnitude),x.units)
+				break
+			except Exception as e:
+				print(e)
+		if isinstance(radius,pint.registry.Quantity):
+			result=decc(math.pi)*decc(radius.magnitude**2)
+
+			return pint.Quantity(result,radius.units)
+		else:
+			return
+
+def lc_frequency():
+	with localcontext() as ctx:
+		ctx.prec=int(db.detectGetOrSet("lsbld ROUNDTO default",4,setValue=False,literal=True))
+		inductance=None
+		capacitance=None
+		while True:
+			try:
+				inductance=Control(func=FormBuilderMkText,ptext=f"{Fore.light_green}Precision {ctx.prec}{Fore.light_yellow} inductance(356 microhenry): ",helpText="coil inductance",data="string")
+				if inductance is None:
+					return
+				elif inductance in ['d',]:
+					inductance="356 microhenry"
+				x=unit_registry.Quantity(inductance)
+				if x:
+					x=x.to("henry")
+				inductance=decc(x.magnitude,cf=20)
+				break
+			except Exception as e:
+				print(e)
+		while True:
+			try:
+				capacitance=Control(func=FormBuilderMkText,ptext=f"{Fore.light_green}Precision {ctx.prec}{Fore.light_yellow} capacitance[365 picofarads]? ",helpText="capacitance in farads",data="string")
+				if capacitance is None:
+					return
+				elif capacitance in ['d',]:
+					capacitance="365 picofarads"
+				x=unit_registry.Quantity(capacitance)
+				if x:
+					x=x.to("farads")
+				farads=decc(x.magnitude,cf=20)
+				break
+			except Exception as e:
+				print(e)
+		frequency=1/(decc(2*math.pi)*decc(math.sqrt(farads*inductance),cf=20))
+		return unit_registry.Quantity(frequency,"hertz")
+
+def area_of_circle_diameter():
+	with localcontext() as ctx:
+		ctx.prec=int(db.detectGetOrSet("lsbld ROUNDTO default",4,setValue=False,literal=True))
+		'''
+	A = πr²
+		'''
+		radius=0
+		while True:
+			try:
+				diameter=Control(func=FormBuilderMkText,ptext=f"{Fore.light_green}Precision {ctx.prec}{Fore.light_yellow} diameter unit[4 cm]? ",helpText="diamater value with unit",data="string")
+				if diameter is None:
+					return
+				elif diameter in ['d',]:
+					diameter="4 cm"
+				x=unit_registry.Quantity(diameter)
+				radius=pint.Quantity(decc(x.magnitude/2),x.units)
+				break
+			except Exception as e:
+				print(e)
+		if isinstance(radius,pint.registry.Quantity):
+			result=decc(math.pi)*decc(radius.magnitude**2)
+
+			return pint.Quantity(result,radius.units)
+		else:
+			return
+
+
 def area_triangle():
 	with localcontext() as ctx:
 		ctx.prec=int(db.detectGetOrSet("lsbld ROUNDTO default",4,setValue=False,literal=True))
@@ -215,7 +597,7 @@ def AddNewTaxRate(excludes=['txrt_id','DTOE']):
 			'type':str(i.type).lower()} for i in tr.__table__.columns if i.name not in excludes
 			}
 
-			fd=FormBuilder(data=fields)
+			fd=FormBuilder(data=fields,passThruText=f"Precision {ctx.prec}")
 			if fd is None:
 				session.delete(tr)
 				return
@@ -244,7 +626,7 @@ def GetTaxRate(excludes=['txrt_id','DTOE']):
 			'type':str(i.type).lower()} for i in tr.__table__.columns if i.name not in excludes
 			}
 
-			fd=FormBuilder(data=fields,passThruText="GetTaxRate Search -> ")
+			fd=FormBuilder(data=fields,passThruText=f"Precision {ctx.prec} ; GetTaxRate Search -> ")
 			if fd is None:
 				return
 			for k in fd:
@@ -297,7 +679,7 @@ def price_by_tax(total=False):
 			'type':'dec.dec'
 			}
 		}
-		fd=FormBuilder(data=fields,passThruText="Tax on Price ->")
+		fd=FormBuilder(data=fields,passThruText=f"Precision {ctx.prec} ; Tax on Price ->")
 		if fd is None:
 			return
 		else:
@@ -329,7 +711,7 @@ def price_plus_crv_by_tax(total=False):
 			'type':'dec.dec'
 			}
 		}
-		fd=FormBuilder(data=fields,passThruText="Tax on (Price+CRV)")
+		fd=FormBuilder(data=fields,passThruText=f"Precision {ctx.prec};Tax on (Price+CRV)")
 		if fd is None:
 			return
 		else:
@@ -493,7 +875,7 @@ def heronsFormula():
 			'type':'dec.dec'
 			},
 		}
-		fd=FormBuilder(data=fields)
+		fd=FormBuilder(data=fields,passThruText=f"Precision {ctx.prec}")
 		if fd is None:
 			return
 
@@ -519,7 +901,7 @@ def volumeCylinderRadius():
 			'type':'dec.dec'
 			},
 		}
-		fd=FormBuilder(data=fields)
+		fd=FormBuilder(data=fields,passThruText=f"Precision {ctx.prec}")
 		if fd is None:
 			return
 
@@ -542,7 +924,7 @@ def volumeCylinderDiameter():
 			'type':'dec.dec'
 			},
 		}
-		fd=FormBuilder(data=fields)
+		fd=FormBuilder(data=fields,passThruText=f"Precision {ctx.prec}")
 		if fd is None:
 			return
 
@@ -565,7 +947,7 @@ def volumeConeRadius():
 			'type':'dec.dec'
 			},
 		}
-		fd=FormBuilder(data=fields)
+		fd=FormBuilder(data=fields,passThruText=f"Precision {ctx.prec}")
 		if fd is None:
 			return
 
@@ -588,9 +970,148 @@ def volumeConeDiameter():
 			'type':'dec.dec'
 			},
 		}
-		fd=FormBuilder(data=fields)
+		fd=FormBuilder(data=fields,passThruText=f"Precision {ctx.prec}")
 		if fd is None:
 			return
 
 		volume=Decimal(1/3)*(Decimal(math.pi)*((fd['diameter']/2)**2)*fd['height'])
-		return volume
+		return volume
+
+def volumeHemisphereRadius():
+	with localcontext() as ctx:
+		ctx.prec=int(db.detectGetOrSet("lsbld ROUNDTO default",4,setValue=False,literal=True))
+		'''
+		Volume of a hemisphere = (2/3) x 3.14 x r3
+		'''
+		fields={
+			'radius':{
+			'default':1,
+			'type':'dec.dec'
+			},
+		}
+		fd=FormBuilder(data=fields,passThruText=f"Precision {ctx.prec}")
+		if fd is None:
+			return
+
+		volume=Decimal(2/3)*Decimal(math.pi)*(fd['radius']**3)
+		return volume
+
+def volumeHemisphereDiameter():
+	with localcontext() as ctx:
+		ctx.prec=int(db.detectGetOrSet("lsbld ROUNDTO default",4,setValue=False,literal=True))
+		'''
+		Volume of a hemisphere = (2/3) x 3.14 x r3
+		'''
+		fields={
+			'diameter':{
+			'default':1,
+			'type':'dec.dec'
+			},
+		}
+		fd=FormBuilder(data=fields,passThruText=f"Precision {ctx.prec}")
+		if fd is None:
+			return
+
+		volume=Decimal(2/3)*Decimal(math.pi)*((fd['diameter']/2)**3)
+		return volume
+
+def areaCircleDiameter():
+	with localcontext() as ctx:
+		ctx.prec=int(db.detectGetOrSet("lsbld ROUNDTO default",4,setValue=False,literal=True))
+		'''
+		Volume of a hemisphere = (2/3) x 3.14 x r3
+		'''
+		fields={
+			'diameter':{
+			'default':1,
+			'type':'dec.dec'
+			},
+		}
+		fd=FormBuilder(data=fields,passThruText=f"Precision {ctx.prec}")
+		if fd is None:
+			return
+
+		volume=Decimal(math.pi)*((fd['diameter']/2)**2)
+		return volume
+
+
+def areaCircleRadius():
+	with localcontext() as ctx:
+		ctx.prec=int(db.detectGetOrSet("lsbld ROUNDTO default",4,setValue=False,literal=True))
+		'''
+		Volume of a hemisphere = (2/3) x 3.14 x r3
+		'''
+		fields={
+			'radius':{
+			'default':1,
+			'type':'dec.dec'
+			},
+		}
+		fd=FormBuilder(data=fields,passThruText=f"Precision {ctx.prec}")
+		if fd is None:
+			return
+
+		volume=Decimal(math.pi)*((fd['radius'])**2)
+		return volume
+
+###newest
+def circumferenceCircleRadiu():
+	#get the circumference of a circle using radius
+	with localcontext() as ctx:
+		ctx.prec=int(db.detectGetOrSet("lsbld ROUNDTO default",4,setValue=False,literal=True))
+		'''
+		2πr
+		'''
+		fields={
+			'radius':{
+			'default':1,
+			'type':'dec.dec'
+			},
+		}
+		fd=FormBuilder(data=fields,passThruText=f"Precision {ctx.prec}")
+		if fd is None:
+			return
+
+		circumference=2*Deimal(math.pi)*fd['radius']
+		return circumference
+
+def circumferenceCircleDiameter():
+	#get the circumference of a circle using diameter
+	with localcontext() as ctx:
+		ctx.prec=int(db.detectGetOrSet("lsbld ROUNDTO default",4,setValue=False,literal=True))
+		'''
+		2π(d/2)
+		'''
+		fields={
+			'diameter':{
+			'default':1,
+			'type':'dec.dec'
+			},
+		}
+		fd=FormBuilder(data=fields,passThruText=f"Precision {ctx.prec}")
+		if fd is None:
+			return
+
+		circumference=2*Deimal(math.pi)*Decimal(fd['diameter']/2)
+		return circumference
+
+'''
+Ellipse: area=πab
+, where 2a
+ and 2b
+ are the lengths of the axes of the ellipse.
+
+Sphere: vol=4πr3/3
+, surface area=4πr2
+.
+
+Cylinder: vol=πr2h
+, lateral area=2πrh
+, total surface area=2πrh+2πr2
+.
+
+
+Cone: vol=πr2h/3
+, lateral area=πrr2+h2−−−−−−√
+, total surface area=πrr2+h2−−−−−−√+πr2
+'''

{radboy-0.0.714.dist-info → radboy-0.0.716.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: radboy
-Version: 0.0.714
+Version: 0.0.716
 Summary: A Retail Calculator for Android/Linux
 Author: Carl Joseph Hirner III
 Author-email: Carl Hirner III <k.j.hirner.wisdom@gmail.com>