


'''simple docstring'''
import numpy as np
import skfuzzy as fuzz

if __name__ == "__main__":
					# Create universe of discourse in Python using linspace ()
					lowerCAmelCase   : Any             =				np.linspace(start=0, stop=7_5, num=7_5, endpoint=True, retstep=False)

					# Create two fuzzy sets by defining any membership function
					# (trapmf(), gbellmf(), gaussmf(), etc).
					lowerCAmelCase   : List[str]             =				[0, 2_5, 5_0]
					lowerCAmelCase   : Union[str, Any]             =				[2_5, 5_0, 7_5]
					lowerCAmelCase   : Optional[int]             =				fuzz.membership.trimf(X, abca)
					lowerCAmelCase   : int             =				fuzz.membership.trimf(X, abca)

					# Compute the different operations using inbuilt functions.
					lowerCAmelCase   : Any             =				np.ones(7_5)
					lowerCAmelCase   : Union[str, Any]             =				np.zeros((7_5,))
					# 1. Union = max(µA(x), µB(x))
					lowerCAmelCase   : List[Any]             =				fuzz.fuzzy_or(X, young, X, middle_aged)[1]
					# 2. Intersection = min(µA(x), µB(x))
					lowerCAmelCase   : str             =				fuzz.fuzzy_and(X, young, X, middle_aged)[1]
					# 3. Complement (A) = (1- min(µA(x))
					lowerCAmelCase   : Optional[int]             =				fuzz.fuzzy_not(young)
					# 4. Difference (A/B) = min(µA(x),(1- µB(x)))
					lowerCAmelCase   : Optional[Any]             =				fuzz.fuzzy_and(X, young, X, fuzz.fuzzy_not(middle_aged)[1])[1]
					# 5. Algebraic Sum = [µA(x) + µB(x) – (µA(x) * µB(x))]
					lowerCAmelCase   : Tuple             =				young + middle_aged - (young * middle_aged)
					# 6. Algebraic Product = (µA(x) * µB(x))
					lowerCAmelCase   : int             =				young * middle_aged
					# 7. Bounded Sum = min[1,(µA(x), µB(x))]
					lowerCAmelCase   : Optional[int]             =				fuzz.fuzzy_and(X, one, X, young + middle_aged)[1]
					# 8. Bounded difference = min[0,(µA(x), µB(x))]
					lowerCAmelCase   : List[Any]             =				fuzz.fuzzy_or(X, zero, X, young - middle_aged)[1]

					# max-min composition
					# max-product composition

					# Plot each set A, set B and each operation result using plot() and subplot().
					from matplotlib import pyplot as plt

					plt.figure()

					plt.subplot(4, 3, 1)
					plt.plot(X, young)
					plt.title("""Young""")
					plt.grid(True)

					plt.subplot(4, 3, 2)
					plt.plot(X, middle_aged)
					plt.title("""Middle aged""")
					plt.grid(True)

					plt.subplot(4, 3, 3)
					plt.plot(X, union)
					plt.title("""union""")
					plt.grid(True)

					plt.subplot(4, 3, 4)
					plt.plot(X, intersection)
					plt.title("""intersection""")
					plt.grid(True)

					plt.subplot(4, 3, 5)
					plt.plot(X, complement_a)
					plt.title("""complement_a""")
					plt.grid(True)

					plt.subplot(4, 3, 6)
					plt.plot(X, difference)
					plt.title("""difference a/b""")
					plt.grid(True)

					plt.subplot(4, 3, 7)
					plt.plot(X, alg_sum)
					plt.title("""alg_sum""")
					plt.grid(True)

					plt.subplot(4, 3, 8)
					plt.plot(X, alg_product)
					plt.title("""alg_product""")
					plt.grid(True)

					plt.subplot(4, 3, 9)
					plt.plot(X, bdd_sum)
					plt.title("""bdd_sum""")
					plt.grid(True)

					plt.subplot(4, 3, 1_0)
					plt.plot(X, bdd_difference)
					plt.title("""bdd_difference""")
					plt.grid(True)

					plt.subplots_adjust(hspace=0.5)
					plt.show()






'''simple docstring'''
def 	_A  (       A							)  ->				list:
	lowercase						:		str   					=		int(A							)
	if n_element < 1:
		lowercase						:		List[Any]   					=		ValueError("a should be a positive number"							)
		raise my_error

	lowercase						:		List[Any]   					=		[1]
	lowercase					,		lowercase					,		lowercase						:		Tuple   					=		(0, 0, 0)
	lowercase						:		Dict   					=		1
	while index < n_element:
		while hamming_list[i] * 2 <= hamming_list[-1]:
			i += 1
		while hamming_list[j] * 3 <= hamming_list[-1]:
			j += 1
		while hamming_list[k] * 5 <= hamming_list[-1]:
			k += 1
		hamming_list.append(
		    min(hamming_list[i] * 2							,hamming_list[j] * 3							,hamming_list[k] * 5							)							)
		index += 1
	return hamming_list


if __name__ == "__main__":
					lowerCAmelCase   : Union[str, Any]             =				input("""Enter the last number (nth term) of the Hamming Number Series: """)
					print("""Formula of Hamming Number Series => 2^i * 3^j * 5^k""")
					lowerCAmelCase   : Tuple             =				hamming(int(n))
					print("""-----------------------------------------------------""")
					print(F'''The list with nth numbers is: {hamming_numbers}''')
					print("""-----------------------------------------------------""")


