AeroViz 0.1.3__py3-none-any.whl → 0.1.4__py3-none-any.whl

AeroViz/tools/database.py

@@ -6,92 +6,90 @@ from pandas import read_csv, DataFrame
 
 
 def load_default_chemical_data():
-	# The following data is from the chemical composition of real atmospheric particles.
-	#
-	# The six main chemical components that comprised PM2.5 are listed in the data.
-	# Here, we test the radar charts to see if we can clearly identify how the
-	# chemical components vary between the three pollutant scenarios:
-	#
-	#  1) Whole sampling period (Total)
-	#  2) Clean period (Clean)
-	#  3) Transition period (Transition)
-	#  4) Event period (Event)
-
-	data = {
-		'Sulfate': [0.01, 0.34, 0.02, 0.71],
-		'Nitrate': [0.88, 0.13, 0.34, 0.13],
-		'OC': [0.07, 0.95, 0.04, 0.05],
-		'EC': [0.20, 0.02, 0.85, 0.19],
-		'Soil': [0.20, 0.10, 0.07, 0.01],
-		'SS': [0.20, 0.10, 0.07, 0.01]
-	}
-
-	return DataFrame(data, index=['Total', 'Clean', 'Transition', 'Event'])
+    # The following data is from the chemical composition of real atmospheric particles.
+    #
+    # The six main chemical components that comprised PM2.5 are listed in the data.
+    # Here, we test the radar charts to see if we can clearly identify how the
+    # chemical components vary between the three pollutant scenarios:
+    #
+    #  1) Whole sampling period (Total)
+    #  2) Clean period (Clean)
+    #  3) Transition period (Transition)
+    #  4) Event period (Event)
+
+    data = {
+        'Sulfate': [0.01, 0.34, 0.02, 0.71],
+        'Nitrate': [0.88, 0.13, 0.34, 0.13],
+        'OC': [0.07, 0.95, 0.04, 0.05],
+        'EC': [0.20, 0.02, 0.85, 0.19],
+        'Soil': [0.20, 0.10, 0.07, 0.01],
+        'SS': [0.20, 0.10, 0.07, 0.01]
+    }
+
+    return DataFrame(data, index=['Total', 'Clean', 'Transition', 'Event'])
 
 
 def load_dataset_by_url(dataset_name: Literal["Tunghai", "Taipei"] = "Tunghai") -> DataFrame:
-	import requests
-	dataset_uris = {
-		"Tunghai": "https://raw.githubusercontent.com/alex870521/DataPlot/main/DataPlot/config/default_data.csv"
-	}
+    import requests
+    dataset_uris = {
+        "Tunghai": "https://raw.githubusercontent.com/alex870521/DataPlot/main/DataPlot/config/default_data.csv"
+    }
 
-	# Ensure the dataset name is valid
-	if dataset_name not in dataset_uris:
-		raise ValueError(f"Dataset {dataset_name} is not supported.")
+    # Ensure the dataset name is valid
+    if dataset_name not in dataset_uris:
+        raise ValueError(f"Dataset {dataset_name} is not supported.")
 
-	url = dataset_uris[dataset_name]
+    url = dataset_uris[dataset_name]
 
-	# Make a request to the URL
-	response = requests.get(url)
+    # Make a request to the URL
+    response = requests.get(url)
 
-	if response.status_code == 200:
-		return read_csv(StringIO(response.text), parse_dates=['Time'], index_col='Time')
-	else:
-		print(f"Failed to download file: {response.status_code}")
-		print(response.text)  # Print the response text for debugging
-		return DataFrame()  # Return an empty DataFrame in case of failure
+    if response.status_code == 200:
+        return read_csv(StringIO(response.text), na_values=('E', 'F', '-', '_', '#', '*'), index_col=0,
+                        parse_dates=True, low_memory=False)
+    else:
+        print(f"Failed to download file: {response.status_code}")
+        print(response.text)  # Print the response text for debugging
+        return DataFrame()  # Return an empty DataFrame in case of failure
 
 
 def load_dataset_local(dataset_name: Literal["Tunghai", "Taipei", "PNSD"] = "Tunghai") -> DataFrame:
-	base_dir = Path(__file__).resolve().parent.parent
-	config_dir = base_dir / 'config'
+    base_dir = Path(__file__).resolve().parent.parent
+    config_dir = base_dir / 'data'
 
-	dataset_paths = {
-		"Tunghai": config_dir / 'DEFAULT_DATA.csv',
-		"Taipei": config_dir / 'DEFAULT_DATA.csv',
-		"PNSD": config_dir / 'DEFAULT_PNSD_DATA.csv'
-	}
+    dataset_paths = {
+        "Tunghai": config_dir / 'DEFAULT_DATA.csv',
+        "Taipei": config_dir / 'DEFAULT_DATA.csv',
+        "PNSD": config_dir / 'DEFAULT_PNSD_DATA.csv'
+    }
 
-	if dataset_name not in dataset_paths:
-		raise ValueError(f"Dataset {dataset_name} is not supported.")
+    if dataset_name not in dataset_paths:
+        raise ValueError(f"Dataset {dataset_name} is not supported.")
 
-	file_path = dataset_paths[dataset_name]
+    file_path = dataset_paths[dataset_name]
 
-	if not file_path.exists():
-		raise FileNotFoundError(f"The file {file_path} does not exist.")
+    if not file_path.exists():
+        raise FileNotFoundError(f"The file {file_path} does not exist.")
 
-	return read_csv(file_path, parse_dates=['Time'], index_col='Time', na_values=('-', 'E', 'F'), low_memory=False)
+    return read_csv(file_path, na_values=('E', 'F', '-', '_', '#', '*'), index_col=0, parse_dates=True,
+                    low_memory=False)
 
 
 class DataBase:
-	def __new__(cls, file_path: Path | str = None, load_data: bool = False, load_PSD: bool = False):
-		print(f'\t\t \033[96m --- Loading Data --- \033[0m')
-		if file_path is not None:
-			file_path = Path(file_path)
-			if file_path.exists():
-				return read_csv(file_path, parse_dates=['Time'], index_col='Time', na_values=('-', 'E', 'F'),
-								low_memory=False)
+    def __new__(cls, file_path: Path | str = None, load_data: bool = False, load_PSD: bool = False):
+        print(f'Loading:\033[96m Default Data\033[0m')
+        if file_path is not None:
+            file_path = Path(file_path)
+            if file_path.exists():
+                return read_csv(file_path, na_values=('E', 'F', '-', '_', '#', '*'), index_col=0, parse_dates=True,
+                                low_memory=False)
 
-		if load_data ^ load_PSD:
-			if load_data:
-				return load_dataset_local("Tunghai")
+        if load_data ^ load_PSD:
+            return load_dataset_local("Tunghai") if load_data else load_dataset_local("PNSD")
 
-			elif load_PSD:
-				return load_dataset_local("PNSD")
-
-		else:
-			raise ValueError("Exactly one of 'load_data' or 'load_PSD' must be True.")
+        else:
+            raise ValueError("Exactly one of 'load_data' or 'load_PSD' must be True.")
 
 
 if __name__ == '__main__':
-	df = DataBase("Tunghai")
+    df = DataBase("Tunghai")

AeroViz/tools/dataclassifier.py

@@ -6,112 +6,112 @@ from pandas import concat, DataFrame, Series
 
 
 class Classifier:
-	Seasons = {'2020-Summer': (datetime(2020, 9, 4), datetime(2020, 9, 21, 23)),
-			   '2020-Autumn': (datetime(2020, 9, 22), datetime(2020, 12, 29, 23)),
-			   '2020-Winter': (datetime(2020, 12, 30), datetime(2021, 3, 25, 23)),
-			   '2021-Spring': (datetime(2021, 3, 26), datetime(2021, 5, 6, 23))}
-
-	# '2021-Summer': (datetime(2021, 5, 7), datetime(2021, 10, 16, 23))
-	# '2021-Autumn': (datetime(2021, 10, 17), datetime(2021, 12, 31, 23))
-
-	@classmethod
-	def classify(cls, df) -> DataFrame:
-		df = cls.classify_by_diurnal(df)
-		df = cls.classify_by_state(df)
-		df = cls.classify_by_season(df)
-		df = cls.classify_by_season_state(df)
-
-		return df
-
-	@classmethod
-	def classify_by_diurnal(cls, df):
-		df['Hour'] = df.index.hour
-		df['Diurnal'] = df['Hour'].apply(cls.map_diurnal)
-		return df
-
-	@classmethod
-	def classify_by_state(cls, df):
-		df['State'] = df.apply(cls.map_state, axis=1, clean_bound=df.Extinction.quantile(0.2),
-							   event_bound=df.Extinction.quantile(0.8))
-		return df
-
-	@classmethod
-	def classify_by_season(cls, df):
-		for season, (season_start, season_end) in cls.Seasons.items():
-			df.loc[season_start:season_end, 'Season'] = season
-		return df
-
-	@classmethod
-	def classify_by_season_state(cls, df):
-		for _grp, _df in df.groupby('Season'):
-			df['Season_State'] = df.apply(cls.map_state, axis=1, clean_bound=_df.Extinction.quantile(0.2),
-										  event_bound=_df.Extinction.quantile(0.8))
-		return df
-
-	@staticmethod
-	def map_diurnal(hour):
-		return 'Day' if 7 <= hour <= 18 else 'Night'
-
-	@staticmethod
-	def map_state(row, clean_bound, event_bound):
-		return 'Event' if row['Extinction'] >= event_bound else 'Clean' if row[
-																			   'Extinction'] < clean_bound else 'Transition'
+    Seasons = {'2020-Summer': (datetime(2020, 9, 4), datetime(2020, 9, 21, 23)),
+               '2020-Autumn': (datetime(2020, 9, 22), datetime(2020, 12, 29, 23)),
+               '2020-Winter': (datetime(2020, 12, 30), datetime(2021, 3, 25, 23)),
+               '2021-Spring': (datetime(2021, 3, 26), datetime(2021, 5, 6, 23))}
+
+    # '2021-Summer': (datetime(2021, 5, 7), datetime(2021, 10, 16, 23))
+    # '2021-Autumn': (datetime(2021, 10, 17), datetime(2021, 12, 31, 23))
+
+    @classmethod
+    def classify(cls, df) -> DataFrame:
+        df = cls.classify_by_diurnal(df)
+        df = cls.classify_by_state(df)
+        df = cls.classify_by_season(df)
+        df = cls.classify_by_season_state(df)
+
+        return df
+
+    @classmethod
+    def classify_by_diurnal(cls, df):
+        df['Hour'] = df.index.hour
+        df['Diurnal'] = df['Hour'].apply(cls.map_diurnal)
+        return df
+
+    @classmethod
+    def classify_by_state(cls, df):
+        df['State'] = df.apply(cls.map_state, axis=1, clean_bound=df.Extinction.quantile(0.2),
+                               event_bound=df.Extinction.quantile(0.8))
+        return df
+
+    @classmethod
+    def classify_by_season(cls, df):
+        for season, (season_start, season_end) in cls.Seasons.items():
+            df.loc[season_start:season_end, 'Season'] = season
+        return df
+
+    @classmethod
+    def classify_by_season_state(cls, df):
+        for _grp, _df in df.groupby('Season'):
+            df['Season_State'] = df.apply(cls.map_state, axis=1, clean_bound=_df.Extinction.quantile(0.2),
+                                          event_bound=_df.Extinction.quantile(0.8))
+        return df
+
+    @staticmethod
+    def map_diurnal(hour):
+        return 'Day' if 7 <= hour <= 18 else 'Night'
+
+    @staticmethod
+    def map_state(row, clean_bound, event_bound):
+        return 'Event' if row['Extinction'] >= event_bound else 'Clean' if row[
+                                                                               'Extinction'] < clean_bound else 'Transition'
 
 
 class DataClassifier(Classifier):
-	"""
-	Notes
-	-----
-	First, create group then return the selected statistic method.
-	If the 'by' does not exist in DataFrame, import the default DataFrame to help to sign the different group.
-
-	"""
-
-	def __new__(cls,
-				df: DataFrame,
-				by: Literal["Hour", "State", "Season", "Season_state"] | str,
-				df_support: DataFrame | Series = None,
-				cut_bins: Sequence = None,
-				qcut: int = None,
-				labels: list[str] = None
-				) -> tuple[DataFrame, DataFrame]:
-		group = cls._group_data(df, by, df_support, cut_bins, qcut, labels)
-		return cls._compute_statistics(df, group)
-
-	@staticmethod
-	def _group_data(df, by, df_support, cut_bins, qcut, labels):
-		if by not in df.columns:
-			if df_support is None:
-				raise KeyError(f"Column '{by}' does not exist in DataFrame."
-							   f"Please provide a support DataFrame or Series to help classify.")
-			else:
-				df = concat([df, Classifier.classify(df_support.copy())[by]], axis=1)
-
-		if cut_bins is not None:
-			df[f'{by}_cut'] = pd.cut(df.loc[:, f'{by}'], cut_bins,
-									 labels=labels or (cut_bins + (cut_bins[1] - cut_bins[0]) / 2)[:-1])
-			return df.groupby(f'{by}_cut', observed=False)
-
-		elif qcut is not None:
-			df[f'{by}_qcut'] = pd.qcut(df.loc[:, f'{by}'], q=qcut, labels=labels)
-			return df.groupby(f'{by}_qcut', observed=False)
-
-		else:
-			if by == 'State':
-				return df.groupby(by)
-
-			elif by == 'Season':
-				return df.groupby(pd.Categorical(df['Season'], categories=['2020-Summer', '2020-Autumn', '2020-Winter',
-																		   '2021-Spring']), observed=False)
-			else:
-				return df.groupby(by, observed=False)
-
-	@staticmethod
-	def _compute_statistics(df, group):
-		mean_df = group.mean(numeric_only=True)
-		mean_df.loc['Total'] = df.mean(numeric_only=True)
-
-		std_df = group.std(numeric_only=True)
-		std_df.loc['Total'] = df.std(numeric_only=True)
-
-		return mean_df, std_df
+    """
+    Notes
+    -----
+    First, create group then return the selected statistic method.
+    If the 'by' does not exist in DataFrame, import the default DataFrame to help to sign the different group.
+
+    """
+
+    def __new__(cls,
+                df: DataFrame,
+                by: Literal["Hour", "State", "Season", "Season_state"] | str,
+                df_support: DataFrame | Series = None,
+                cut_bins: Sequence = None,
+                qcut: int = None,
+                labels: list[str] = None
+                ) -> tuple[DataFrame, DataFrame]:
+        group = cls._group_data(df, by, df_support, cut_bins, qcut, labels)
+        return cls._compute_statistics(df, group)
+
+    @staticmethod
+    def _group_data(df, by, df_support, cut_bins, qcut, labels):
+        if by not in df.columns:
+            if df_support is None:
+                raise KeyError(f"Column '{by}' does not exist in DataFrame."
+                               f"Please provide a support DataFrame or Series to help classify.")
+            else:
+                df = concat([df, Classifier.classify(df_support.copy())[by]], axis=1)
+
+        if cut_bins is not None:
+            df[f'{by}_cut'] = pd.cut(df.loc[:, f'{by}'], cut_bins,
+                                     labels=labels or (cut_bins + (cut_bins[1] - cut_bins[0]) / 2)[:-1])
+            return df.groupby(f'{by}_cut', observed=False)
+
+        elif qcut is not None:
+            df[f'{by}_qcut'] = pd.qcut(df.loc[:, f'{by}'], q=qcut, labels=labels)
+            return df.groupby(f'{by}_qcut', observed=False)
+
+        else:
+            if by == 'State':
+                return df.groupby(by)
+
+            elif by == 'Season':
+                return df.groupby(pd.Categorical(df['Season'], categories=['2020-Summer', '2020-Autumn', '2020-Winter',
+                                                                           '2021-Spring']), observed=False)
+            else:
+                return df.groupby(by, observed=False)
+
+    @staticmethod
+    def _compute_statistics(df, group):
+        mean_df = group.mean(numeric_only=True)
+        mean_df.loc['Total'] = df.mean(numeric_only=True)
+
+        std_df = group.std(numeric_only=True)
+        std_df.loc['Total'] = df.std(numeric_only=True)
+
+        return mean_df, std_df

AeroViz/tools/dataprinter.py

@@ -5,54 +5,54 @@ from tabulate import tabulate
 
 
 def data_table(df: DataFrame,
-			   items: list[str] | str = None,
-			   times: list[datetime | Timestamp | str] = None,
-			   ):
-	"""
-	This function cuts the DataFrame based on the given time periods and calculates the mean and standard deviation
-	of the specified items for each period.
-
-	Parameters
-	----------
-	df : pd.DataFrame
-		The DataFrame to be processed. It should have a DateTime index.
-	items : list[str] | str, optional
-		The columns of the DataFrame to be processed. It can be a list of column names or a single column name.
-		By default, it is ['NO', 'NO2', 'NOx'].
-	times : list[str] | str, optional
-		The time periods to cut the DataFrame. It can be a list of time strings or a single time string.
-		Each time string should be in the format of 'YYYY-MM-DD'. By default, it is ['2024-03-21', '2024-04-30'].
-
-	Returns
-	-------
-	None
-		This function doesn't return any value. It prints out a table showing the mean and standard deviation
-		of the specified items for each time period.
-	"""
-	items = [items] if isinstance(items, str) else items
-	times = [times] if isinstance(times, str) else times
-	times = list(map(Timestamp, times))
-
-	times.sort()
-
-	results = []
-	periods = []
-	for i in range(len(times) + 1):
-		if i == 0:
-			df_period = df.loc[df.index <= times[i], items]
-			period_label = f'Before {times[i].date()}'
-		elif i == len(times):
-			df_period = df.loc[df.index > times[i - 1], items]
-			period_label = f'After {times[i - 1].date()}'
-		else:
-			df_period = df.loc[(df.index > times[i - 1]) & (df.index <= times[i]), items]
-			period_label = f'{times[i - 1].date()} to {times[i].date()}'
-
-		mean, std = df_period.mean().round(2).to_numpy(), df_period.std().round(2).to_numpy()
-
-		results.append([f'{m} ± {s}' for m, s in zip(mean, std)])
-		periods.append(period_label)
-
-	result = DataFrame(results, columns=items, index=periods)
-
-	print(tabulate(result, headers='keys', tablefmt='fancy_grid'))
+               items: list[str] | str = None,
+               times: list[datetime | Timestamp | str] = None,
+               ):
+    """
+    This function cuts the DataFrame based on the given time periods and calculates the mean and standard deviation
+    of the specified items for each period.
+
+    Parameters
+    ----------
+    df : pd.DataFrame
+        The DataFrame to be processed. It should have a DateTime index.
+    items : list[str] | str, optional
+        The columns of the DataFrame to be processed. It can be a list of column names or a single column name.
+        By default, it is ['NO', 'NO2', 'NOx'].
+    times : list[str] | str, optional
+        The time periods to cut the DataFrame. It can be a list of time strings or a single time string.
+        Each time string should be in the format of 'YYYY-MM-DD'. By default, it is ['2024-03-21', '2024-04-30'].
+
+    Returns
+    -------
+    None
+        This function doesn't return any value. It prints out a table showing the mean and standard deviation
+        of the specified items for each time period.
+    """
+    items = [items] if isinstance(items, str) else items
+    times = [times] if isinstance(times, str) else times
+    times = list(map(Timestamp, times))
+
+    times.sort()
+
+    results = []
+    periods = []
+    for i in range(len(times) + 1):
+        if i == 0:
+            df_period = df.loc[df.index <= times[i], items]
+            period_label = f'Before {times[i].date()}'
+        elif i == len(times):
+            df_period = df.loc[df.index > times[i - 1], items]
+            period_label = f'After {times[i - 1].date()}'
+        else:
+            df_period = df.loc[(df.index > times[i - 1]) & (df.index <= times[i]), items]
+            period_label = f'{times[i - 1].date()} to {times[i].date()}'
+
+        mean, std = df_period.mean().round(2).to_numpy(), df_period.std().round(2).to_numpy()
+
+        results.append([f'{m} ± {s}' for m, s in zip(mean, std)])
+        periods.append(period_label)
+
+    result = DataFrame(results, columns=items, index=periods)
+
+    print(tabulate(result, headers='keys', tablefmt='fancy_grid'))

AeroViz/tools/datareader.py

@@ -5,62 +5,62 @@ from pandas import read_csv, read_json, read_excel, DataFrame
 
 
 class FileHandler(ABC):
-	""" An abstract base class for reading data files with different extensions (.csv, .json, .xls, .xlsx). """
+    """ An abstract base class for reading data files with different extensions (.csv, .json, .xls, .xlsx). """
 
-	@abstractmethod
-	def read_data(self, file_path: Path) -> DataFrame:
-		pass
+    @abstractmethod
+    def read_data(self, file_path: Path) -> DataFrame:
+        pass
 
 
 class CsvFileHandler(FileHandler):
-	def read_data(self, file_path: Path) -> DataFrame:
-		return read_csv(file_path, na_values=('-', 'E', 'F', '#', '*'),
-						parse_dates=['Time'], index_col='Time', low_memory=False)
+    def read_data(self, file_path: Path) -> DataFrame:
+        return read_csv(file_path, na_values=('E', 'F', '-', '_', '#', '*'), index_col=0, parse_dates=True,
+                        low_memory=False)
 
 
 class JsonFileHandler(FileHandler):
-	def read_data(self, file_path: Path) -> DataFrame:
-		return read_json(file_path)
+    def read_data(self, file_path: Path) -> DataFrame:
+        return read_json(file_path)
 
 
 class ExcelFileHandler(FileHandler):
-	def read_data(self, file_path: Path) -> DataFrame:
-		return read_excel(file_path, parse_dates=['Time'])
+    def read_data(self, file_path: Path) -> DataFrame:
+        return read_excel(file_path, index_col=0, parse_dates=True, )
 
 
 class DataReaderFactory:
-	_handler_mapping = {
-		'.csv': CsvFileHandler(),
-		'.json': JsonFileHandler(),
-		'.xls': ExcelFileHandler(),
-		'.xlsx': ExcelFileHandler(),
-	}
+    _handler_mapping = {
+        '.csv': CsvFileHandler(),
+        '.json': JsonFileHandler(),
+        '.xls': ExcelFileHandler(),
+        '.xlsx': ExcelFileHandler(),
+    }
 
-	@staticmethod
-	def create_handler(file_extension: str) -> FileHandler:
-		reader_class = DataReaderFactory._handler_mapping.get(file_extension)
-		if reader_class is None:
-			raise ValueError(f"Unsupported file format: {file_extension}")
-		return reader_class
+    @staticmethod
+    def create_handler(file_extension: str) -> FileHandler:
+        reader_class = DataReaderFactory._handler_mapping.get(file_extension)
+        if reader_class is None:
+            raise ValueError(f"Unsupported file format: {file_extension}")
+        return reader_class
 
 
 class DataReader:
-	"""
-	A class for reading data files with different extensions (.csv, .json, .xls, .xlsx).
+    """
+    A class for reading data files with different extensions (.csv, .json, .xls, .xlsx).
 
-	Parameters
-	----------
-		filename (Path | str): The name of the file to be read or the Path of the file.
+    Parameters
+    ----------
+        filename (Path | str): The name of the file to be read or the Path of the file.
 
-	Returns
-	-------
-		pandas.DataFrame: data
+    Returns
+    -------
+        pandas.DataFrame: data
 
-	Examples
-	--------
-	>>> psd = DataReader(Path(...))
-	"""
+    Examples
+    --------
+    >>> psd = DataReader(Path(...))
+    """
 
-	def __new__(cls, file_path: Path | str) -> DataFrame:
-		file_path = Path(file_path)
-		return DataReaderFactory.create_handler(file_path.suffix.lower()).read_data(file_path)
+    def __new__(cls, file_path: Path | str) -> DataFrame:
+        file_path = Path(file_path)
+        return DataReaderFactory.create_handler(file_path.suffix.lower()).read_data(file_path)

{AeroViz-0.1.3.dist-info → AeroViz-0.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: AeroViz
-Version: 0.1.3
+Version: 0.1.4
 Summary: Aerosol science
 Home-page: https://github.com/Alex870521/AeroViz
 Author: alex
@@ -43,9 +43,10 @@ Requires-Dist: tabulate
 
 ## <div align="center">Key Features</div>
 
-* #### Data Reading: Supports reading multiple aerosol data formats.
-* #### Data Visualization: Offers various charts and graphs, including time series plots, distribution plots, and correlation matrices.
-* #### Data Processing: Includes multiple data processing tools, such as linear regression and Mie theory calculations.
+* Data Reading: Supports reading multiple aerosol data formats.
+* Data Visualization: Offers various charts and graphs, including time series plots, distribution plots, and correlation
+  matrices.
+* Data Processing: Includes multiple data processing tools, such as linear regression and Mie theory calculations.
 
 
 ## <div align="center">Installation</div>