diff --git a/pycomplexity/analysis.py b/pycomplexity/analysis.py
index df04339..5d3db33 100644
--- a/pycomplexity/analysis.py
+++ b/pycomplexity/analysis.py
@@ -1,8 +1,5 @@
import ast
-import shutil
-from typing import List, Tuple
from pprint import pprint
-from enum import Enum
'''
@@ -27,66 +24,3 @@ def visit_Import(self, node):
def report(self):
pprint(self.stats)
-
-
-'''
-Notation format enum
-'''
-class NotationFormat(Enum):
-
- BIG_O : str = 'BIG O'
- BIG_OMEGA : str = 'BIG Ω (OMEGA)'
- BIG_THETA : str = 'BIG Θ (THETA)'
-
- def __str__(self) -> str:
- return str(self.value)
-
-
-'''
-Class that contains and represents analysis data
-'''
-class AnalysisFormatter:
-
- def __init__(
- self,
- notation_format: NotationFormat,
- func_name: str = 'No name',
- func_attrs: List[Tuple[str, str]] | None = None,
- complexity: str = '1',
- memory: str = '1',
- ) -> None:
-
- self.notation_format = notation_format
- self.func_name = func_name
- self.func_attrs = func_attrs
- self.complexity = complexity
- self.memory = memory
-
- def report(self, full=True):
-
- print()
-
- if full:
- print('Function name:', self.func_name)
-
- if self.func_attrs:
- print('Function attributes:', ', '.join([f'{attr_name}: {attr_type}' for attr_name, attr_type in self.func_attrs]))
-
- terminal_width = shutil.get_terminal_size().columns
- indent = max((terminal_width - len(self.notation_format.__str__()) - 2)//2, 0)
- print('-' * indent + f' {self.notation_format.__str__()} ' + '-' * indent)
-
- if self.notation_format == NotationFormat.BIG_O:
- print('Сomplexity of algorithm: O({})'.format(self.complexity))
- print('Memory of algorithm: O({})'.format(self.memory))
-
- if self.notation_format == NotationFormat.BIG_OMEGA:
- print('Сomplexity of algorithm: Ω({})'.format(self.complexity))
- print('Memory of algorithm: Ω({})'.format(self.memory))
-
- if self.notation_format == NotationFormat.BIG_THETA:
- print('Сomplexity of algorithm: Θ({})'.format(self.complexity))
- print('Memory of algorithm: Θ({})'.format(self.memory))
-
- print()
-
\ No newline at end of file
diff --git a/pycomplexity/enums.py b/pycomplexity/enums.py
new file mode 100644
index 0000000..d887e3f
--- /dev/null
+++ b/pycomplexity/enums.py
@@ -0,0 +1,38 @@
+from enum import Enum
+
+'''
+Notation format enum
+'''
+class NotationFormat(Enum):
+
+ BIG_O : str = 'BIG O'
+ BIG_OMEGA : str = 'BIG Ω (OMEGA)'
+ BIG_THETA : str = 'BIG Θ (THETA)'
+
+ def __str__(self) -> str:
+ return self.value
+
+
+'''
+The most common Big O complexity notations enum
+'''
+class CommonBigO(Enum):
+
+ NON_COMMON : str = 'Non common'
+ CONSTANT : str = '1'
+ LINEAR : str = 'N'
+ LOGARITHMIC : str = 'log(N)'
+ LINEARITHMIC : str = 'N*log(N)'
+ QUADRATIC : str = 'N^2'
+ CUBIC : str = 'N^3'
+ EXPONENTIAL : str = '2^N'
+ FACTORIAL : str = 'N!'
+
+ def __str__(self) -> str:
+ if self is not self.NON_COMMON:
+ return f'O({self.value})'
+ return self.value
+
+ def __repr__(self) -> str:
+ _formatted = self.name.replace('_', ' ').capitalize()
+ return f'{_formatted} time complexity'
\ No newline at end of file
diff --git a/pycomplexity/formatters.py b/pycomplexity/formatters.py
new file mode 100644
index 0000000..5281b8d
--- /dev/null
+++ b/pycomplexity/formatters.py
@@ -0,0 +1,52 @@
+import shutil
+from typing import List, Tuple
+from .enums import NotationFormat
+
+'''
+Class that contains and represents analysis data
+'''
+class AnalysisFormatter:
+
+ def __init__(
+ self,
+ notation_format: NotationFormat,
+ func_name: str = 'No name',
+ func_attrs: List[Tuple[str, str]] | None = None,
+ complexity: str = '1',
+ memory: str = '1',
+ ) -> None:
+
+ self.notation_format = notation_format
+ self.func_name = func_name
+ self.func_attrs = func_attrs
+ self.complexity = complexity
+ self.memory = memory
+
+ def report(self, full=True):
+
+ print()
+
+ if full:
+ print('Function name:', self.func_name)
+
+ if self.func_attrs:
+ print('Function attributes:', ', '.join([f'{attr_name}: {attr_type}' for attr_name, attr_type in self.func_attrs]))
+
+ terminal_width = shutil.get_terminal_size().columns
+ indent = max((terminal_width - len(self.notation_format.__str__()) - 2)//2, 0)
+ print('-' * indent + f' {self.notation_format.__str__()} ' + '-' * indent)
+
+ if self.notation_format == NotationFormat.BIG_O:
+ print('Сomplexity of algorithm: O({})'.format(self.complexity))
+ print('Memory of algorithm: O({})'.format(self.memory))
+
+ if self.notation_format == NotationFormat.BIG_OMEGA:
+ print('Сomplexity of algorithm: Ω({})'.format(self.complexity))
+ print('Memory of algorithm: Ω({})'.format(self.memory))
+
+ if self.notation_format == NotationFormat.BIG_THETA:
+ print('Сomplexity of algorithm: Θ({})'.format(self.complexity))
+ print('Memory of algorithm: Θ({})'.format(self.memory))
+
+ print()
+
\ No newline at end of file
diff --git a/pycomplexity/notations.py b/pycomplexity/notations.py
index 0b25362..9435537 100644
--- a/pycomplexity/notations.py
+++ b/pycomplexity/notations.py
@@ -2,7 +2,9 @@
import inspect
from typing import List, Tuple
-from .analysis import Analyzer, AnalysisFormatter, NotationFormat
+from .analysis import Analyzer
+from .formatters import AnalysisFormatter
+from .enums import NotationFormat, CommonBigO
'''
Base class of asymptotic notation
@@ -54,6 +56,118 @@ class BigO(AsymptoticNotation):
def __init__(self) -> None:
super().__init__()
+
+ def constant(self, func) -> CommonBigO:
+ is_constant = False
+
+ '''
+ TODO: function that checks if algorithm has constant complexity
+ '''
+
+ if is_constant:
+ return CommonBigO.CONSTANT
+ return CommonBigO.NON_COMMON
+
+ def linear(self, func) -> CommonBigO:
+ is_linear = False
+
+ '''
+ TODO: function that checks if algorithm has linear complexity
+ '''
+
+ if is_linear:
+ return CommonBigO.LINEAR
+ return CommonBigO.NON_COMMON
+
+ def logarithmic(self, func) -> CommonBigO:
+ is_logarithmic = False
+
+ '''
+ TODO: function that checks if algorithm has logarithmic complexity
+ '''
+
+ if is_logarithmic:
+ return CommonBigO.LOGARITHMIC
+ return CommonBigO.NON_COMMON
+
+ def linearithmic(self, func) -> CommonBigO:
+ is_linearithmic = False
+
+ '''
+ TODO: function that checks if algorithm has linearithmic complexity
+ '''
+
+ if is_linearithmic:
+ return CommonBigO.LINEARITHMIC
+ return CommonBigO.NON_COMMON
+
+ def quadratic(self, func) -> CommonBigO:
+ is_quadratic = False
+
+ '''
+ TODO: function that checks if algorithm has quadratic complexity
+ '''
+
+ if is_quadratic:
+ return CommonBigO.QUADRATIC
+ return CommonBigO.NON_COMMON
+
+ def cubic(self, func) -> CommonBigO:
+ is_cubic = False
+
+ '''
+ TODO: function that checks if algorithm has cubic complexity
+ '''
+
+ if is_cubic:
+ return CommonBigO.CUBIC
+ return CommonBigO.NON_COMMON
+
+ def exponential(self, func) -> CommonBigO:
+ is_exponential = False
+
+ '''
+ TODO: function that checks if algorithm has exponential complexity
+ '''
+
+ if is_exponential:
+ return CommonBigO.EXPONENTIAL
+ return CommonBigO.NON_COMMON
+
+ def factorial(self, func) -> CommonBigO:
+ is_factorial = False
+
+ '''
+ TODO: function that checks if algorithm has factorial complexity
+ '''
+
+ if is_factorial:
+ return CommonBigO.FACTORIAL
+ return CommonBigO.NON_COMMON
+
+ def _calculate_complexity(self, func) -> CommonBigO:
+ checking_funcs = [
+ self.constant,
+ self.linear,
+ self.logarithmic,
+ self.linearithmic,
+ self.quadratic,
+ self.cubic,
+ self.exponential,
+ self.factorial,
+ ]
+
+ _complexities = []
+ for _check in checking_funcs:
+ if (_complexity := _check(func)) is not CommonBigO.NON_COMMON:
+ _complexities.append(_complexity)
+
+ if _complexities:
+ # returns the minimum from the list of possible complexities
+ return _complexities[0]
+
+ # if all checking funcs returns CommonBigO.NON_COMMON
+ return CommonBigO.NON_COMMON
@AsymptoticNotation.report
def complexity(self, func) -> AnalysisFormatter: