radboy 0.0.713__py3-none-any.whl → 0.0.715__py3-none-any.whl

radboy/preloader/preloader.py

@@ -1,362 +1,5 @@
 from . import *
 
-def volume():
-	height=Prompt.__init2__(None,func=FormBuilderMkText,ptext="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="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="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():
-	height=Prompt.__init2__(None,func=FormBuilderMkText,ptext="height?: ",helpText="height=1",data="string")
-	if height is None:
-		return
-	elif height in ['d',]:
-		height='1'
-	
-	width=Prompt.__init2__(None,func=FormBuilderMkText,ptext="width?: ",helpText="width=1 ",data="string")
-	if width is None:
-		return
-	elif width in ['d',]:
-		width='1'
-	
-
-
-	length=Prompt.__init2__(None,func=FormBuilderMkText,ptext="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():
-	relative_permeability=Prompt.__init2__(None,func=FormBuilderMkText,ptext="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="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="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="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():
-	hertz=1e9
-	while True:
-		try:
-			hertz=Control(func=FormBuilderMkText,ptext="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="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():
-	'''C = 1 / (4π²f²L)'''
-	while True:
-		try:
-			frequency=Control(func=FormBuilderMkText,ptext="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="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():
-	'''
-	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="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="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="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="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():
-	radius=0
-	while True:
-		try:
-			diameter=Control(func=FormBuilderMkText,ptext="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():
-	radius=0
-	while True:
-		try:
-			diameter=Control(func=FormBuilderMkText,ptext="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():
-	'''
-A = πr²
-	'''
-	radius=0
-	while True:
-		try:
-			diameter=Control(func=FormBuilderMkText,ptext="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():
-	inductance=None
-	capacitance=None
-	while True:
-		try:
-			inductance=Control(func=FormBuilderMkText,ptext="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="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():
-	'''
-A = πr²
-	'''
-	radius=0
-	while True:
-		try:
-			diameter=Control(func=FormBuilderMkText,ptext="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
-
 
 preloader={
 	f'{uuid1()}':{
@@ -428,8 +71,8 @@ Here:
 						'exec':lc_frequency,
 					},
 					f'{uuid1()}':{
-						'cmds':['area of a triangle',],
-						'desc':f'A=BH/2',
+						'cmds':[i for i in generate_cmds(startcmd=['triangle','trngl'],endCmd=['area','a'])],
+						'desc':f'A=BH/2 = area of a triangle',
 						'exec':area_triangle,
 					},
 					f'{uuid1()}':{
@@ -462,6 +105,60 @@ Here:
 						'desc':f'multiply a (price+crv) times its tax rate plus (price+crv) and return the total',
 						'exec':lambda: price_plus_crv_by_tax(total=True),
 					},
+					f'{uuid1()}':{
+						'cmds':[i for i in generate_cmds(startcmd=['cylinder','clndr'],endCmd=['vol rad','volume radius'])],
+						'desc':f'obtain the volume of a cylinder using radius',
+						'exec':lambda: volumeCylinderRadius(),
+					},
+					f'{uuid1()}':{
+						'cmds':[i for i in generate_cmds(startcmd=['cylinder','clndr'],endCmd=['vol diam','volume diameter'])],
+						'desc':f'obtain the volume of a cylinder using diameter',
+						'exec':lambda: volumeCylinderDiameter(),
+					},
+					f'{uuid1()}':{
+						'cmds':[i for i in generate_cmds(startcmd=['cone',],endCmd=['vol rad','volume radius'])],
+						'desc':f'obtain the volume of a cone using radius, a cone is 1/3 of a cylinder at the same height and radius',
+						'exec':lambda: volumeConeRadius(),
+					},
+					f'{uuid1()}':{
+						'cmds':[i for i in generate_cmds(startcmd=['cone',],endCmd=['vol diam','volume diameter'])],
+						'desc':f'obtain the volume of a cone using diameter, a code is 1/3 of a cylinder at the same height and diameter',
+						'exec':lambda: volumeConeDiameter(),
+					},
+					f'{uuid1()}':{
+						'cmds':[i for i in generate_cmds(startcmd=['hemisphr','hemisphere'],endCmd=['vol rad','volume radius'])],
+						'desc':f'obtain the volume of a hemisphere using radius',
+						'exec':lambda: volumeHemisphereRadius(),
+					},
+					f'{uuid1()}':{
+						'cmds':[i for i in generate_cmds(startcmd=['hemisphr','hemisphere'],endCmd=['vol diam','volume diameter'])],
+						'desc':f'obtain the volume of a hemisphere using diameter',
+						'exec':lambda: volumeHemisphereDiameter(),
+					},
+					f'{uuid1()}':{
+						'cmds':[i for i in generate_cmds(startcmd=['circle',],endCmd=['area radius','area rad'])],
+						'desc':f'obtain the area of a circle using radius',
+						'exec':lambda: areaCircleRadius(),
+					},
+					f'{uuid1()}':{
+						'cmds':[i for i in generate_cmds(startcmd=['circle',],endCmd=['area diameter','area diam'])],
+						'desc':f'obtain the area of a circle using diameter',
+						'exec':lambda: areaCircleDiameter(),
+					},
+					f'{uuid1()}':{
+						'cmds':['herons formula','hrns fmla'],
+						'desc':f'''
+Heron's formula calculates the area of any 
+triangle given only the lengths of its 
+three sides (a, b, and c). The formula is: 
+Area = √(s(s-a)(s-b)(s-c)). To use it, first
+ calculate the semi-perimeter, s = (a + b 
+ + c) / 2, and then substitute this value 
+ and the side lengths into the formula to 
+ find the area. 
+						''',
+						'exec':lambda: heronsFormula(),
+					},
 					f'{uuid1()}':{
 						'cmds':['tax add',],
 						'desc':'''AddNewTaxRate() -> None