FinalExercise

FinalExercise/Blocks.cpp

@@ -0,0 +1,112 @@
+#include "pch.h"
+#include "Blocks.h"
+#include <algorithm>
+
+double identity::Calculate(const double input)
+{
+  return input;
+}
+
+std::wstring identity::GetName()
+{
+  return L"identity";
+}
+
+std::wstringstream identity::GetArgumentsType()
+{
+  std::wstringstream ss(L"\nNo additional params");
+  return ss;
+}
+
+int identity::GetNumberOfParams()
+{
+  return 0;
+}
+
+std::wstringstream identity::GetParamValues()
+{
+  std::wstringstream ss;
+  ss << "()";
+  return ss;
+}
+
+addition::addition(const double a) : BlockWithOneParam(a)
+{
+}
+
+double addition::Calculate(const double input)
+{
+  return input + param;
+}
+
+std::wstring addition::GetName()
+{
+  return L"addition";
+}
+
+multiplication::multiplication(double a) : BlockWithOneParam(a)
+{
+}
+
+double multiplication::Calculate(const double input)
+{
+  return input * param;
+}
+
+std::wstring multiplication::GetName()
+{
+  return L"multiplication";
+}
+
+power::power(double a) : BlockWithOneParam(a)
+{
+}
+
+double power::Calculate(const double input)
+{
+  return std::pow(input, param);
+}
+
+std::wstring power::GetName()
+{
+  return L"power";
+}
+
+limit::limit(double a, double b) : BlockWithTwoParams(a, b)
+{
+}
+
+double limit::Calculate(const double input)
+{
+  return std::clamp(input, param1, param2);
+}
+
+std::wstring limit::GetName()
+{
+  return L"limit";
+}
+
+condition::condition(double a) : BlockWithOneParam(a)
+{
+}
+
+double condition::Calculate(const double input)
+{
+  if (input == param)
+  {
+    return 0;
+  }
+  else if (input < param)
+  {
+    return -1;
+  }
+  else
+  {
+    return 1;
+  }
+}
+
+std::wstring condition::GetName()
+{
+  return L"condition";
+}

FinalExercise/Blocks.h

@@ -0,0 +1,143 @@
+#pragma once
+#include <sstream>
+
+class Block
+{
+public:
+  virtual ~Block() = default;
+
+  virtual double Calculate(double input) = 0;
+  virtual std::wstring GetName() = 0;
+  virtual std::wstringstream GetArgumentsType() = 0;
+  virtual int GetNumberOfParams() = 0;
+  virtual std::wstringstream GetParamValues() = 0;
+};
+
+template<typename T>
+class BlockWithOneParam : public Block
+{
+public:
+
+  BlockWithOneParam(T a) : param(a)
+  {
+  }
+  std::wstringstream GetArgumentsType() override
+  {
+    std::wstringstream ss;
+    ss << "\nAdd 1 additional argument:" <<
+      "\nargument type " << typeid(param).name() << std::endl;
+    return ss;
+  }
+
+  int GetNumberOfParams() override
+  {
+    return 1;
+  }
+
+  std::wstringstream GetParamValues() override
+  {
+    std::wstringstream ss;
+    ss << "(" << param << ")";
+    return ss;
+  }
+
+protected:
+  T param;
+};
+
+template<typename T1, typename T2>
+class BlockWithTwoParams : public Block
+{
+public:
+  BlockWithTwoParams(T1 a, T2 b) : param1(a), param2(b)
+  {
+  }
+
+  std::wstringstream GetArgumentsType() override
+  {
+    std::wstringstream ss;
+    ss << "\nAdd 2 additional arguments:" <<
+      "\n1. argument type " << typeid(param1).name() <<
+      "\n2. argument type " << typeid(param2).name() << std::endl;
+    return  ss;
+  }
+
+  int GetNumberOfParams() override
+  {
+    return 2;
+  }
+
+  std::wstringstream GetParamValues() override
+  {
+    std::wstringstream ss;
+    ss << "(" << param1 << ", " << param2 << ")";
+    return ss;
+  }
+
+protected:
+  T1 param1;
+  T2 param2;
+};
+
+class identity : public Block
+{
+public:
+  double Calculate(double input) override;
+  std::wstring GetName() override;
+  std::wstringstream GetArgumentsType() override;
+  int GetNumberOfParams() override;
+  std::wstringstream GetParamValues() override;
+};
+
+class addition : public BlockWithOneParam<double>
+{
+public:
+  addition(double a);
+  double Calculate(double input) override;
+  std::wstring GetName() override;
+};
+
+class multiplication : public BlockWithOneParam<double>
+{
+public:
+  multiplication(double a);
+  double Calculate(double input) override;
+  std::wstring GetName() override;
+};
+
+class power : public BlockWithOneParam<double>
+{
+public:
+  power(double a);
+  double Calculate(double input) override;
+  std::wstring GetName() override;
+};
+
+class limit : public BlockWithTwoParams<double, double>
+{
+public:
+  limit(double a, double b);
+  double Calculate(double input) override;
+  std::wstring GetName() override;
+};
+
+class condition : public BlockWithOneParam<double>
+{
+public:
+  condition(double a);
+  double Calculate(double input) override;
+  std::wstring GetName() override;
+};
+
+enum class BlockId
+{
+  identity = 1,
+  addition = 2,
+  multiplication = 3,
+  power = 4,
+  limit = 5,
+  condition = 6
+};
+
+const BlockId BlockIds[] = { BlockId::identity, BlockId::addition, BlockId::multiplication,
+  BlockId::power, BlockId::limit, BlockId::condition };