diff --git a/src/main/java/ru/spbstu/kspt/task1/Dimensions.java b/src/main/java/ru/spbstu/kspt/task1/Dimensions.java
new file mode 100644
index 0000000..043dec2
--- /dev/null
+++ b/src/main/java/ru/spbstu/kspt/task1/Dimensions.java
@@ -0,0 +1,62 @@
+package ru.spbstu.kspt.task1;
+
+import java.util.*;
+
+/**
+ * Класс размерности
+ */
+public class Dimensions {
+
+    Dimensions(){
+
+    }
+
+    private Map<String,Double> dimens = new HashMap<>();
+
+    static Dimensions getLengthDimensions() {
+        return new Dimensions().addDimension("км",100000).addDimension("м",100).
+                addDimension("дм",10).addDimension("см",1);
+    }
+
+    static Dimensions getTimeDimensions() {
+        return new Dimensions().addDimension("с",1).addDimension("мин",60).
+                addDimension("ч",3600);
+    }
+
+    static Dimensions getWeightDimensions() {
+        return new Dimensions().addDimension("кг",1000000).addDimension("г",1000).
+                addDimension("мг",1);
+    }
+
+    Dimensions addDimension(String name, double coefficient) {
+        dimens.put(name, coefficient);
+        return this;
+    }
+
+    double getDimensionValue(String dimension) {
+        if (!dimens.containsKey(dimension)) {
+            throw new IllegalArgumentException("Данная разменость не содержится в данном Map");
+        }
+        return dimens.get(dimension);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        Dimensions dimension = (Dimensions) o;
+
+        return dimens != null ? dimens.equals(dimension.dimens) : dimension.dimens == null;
+    }
+
+    @Override
+    public int hashCode() {
+        return dimens != null ? dimens.hashCode() : 0;
+    }
+
+    @Override
+    public String toString() {
+        return "Dimension{" + dimens + '}';
+    }
+}
diff --git a/src/main/java/ru/spbstu/kspt/task1/Main.java b/src/main/java/ru/spbstu/kspt/task1/Main.java
index 0b91675..9294335 100644
--- a/src/main/java/ru/spbstu/kspt/task1/Main.java
+++ b/src/main/java/ru/spbstu/kspt/task1/Main.java
@@ -14,3 +14,7 @@ public static void main(String[] args) {
         System.out.println("Hello World!");
     }
 }
+
+
+
+
diff --git a/src/main/java/ru/spbstu/kspt/task1/NumberWithDimension.java b/src/main/java/ru/spbstu/kspt/task1/NumberWithDimension.java
new file mode 100644
index 0000000..337455f
--- /dev/null
+++ b/src/main/java/ru/spbstu/kspt/task1/NumberWithDimension.java
@@ -0,0 +1,127 @@
+package ru.spbstu.kspt.task1;
+
+
+/**
+ * Класс числа с размерностью
+ */
+class NumberWithDimension implements Comparable<NumberWithDimension>, NumberWithDimensionInterface {
+
+    private double number;
+
+    private String dimension;
+
+    private Dimensions dimensionClass;
+
+    @Override
+    public double getNumber() {
+        return number;
+    }
+
+    @Override
+    public String getDimension() {
+        return dimension;
+    }
+
+    NumberWithDimension(double number, String dimension, Dimensions dimensionClass) {
+        this.number = number;
+        this.dimension = dimension;
+        this.dimensionClass = dimensionClass;
+    }
+
+    /**
+     * Дублирующий метод для вычисления чисел с размерностью. Используется во многих дальнейших функциях.
+     */
+    private double calculation(NumberWithDimension other) {
+        if(!dimensionClass.equals(other.dimensionClass)) {
+            throw new IllegalArgumentException("Размерности не совпадают");
+        }
+        return other.number * (other.dimensionClass.getDimensionValue(other.dimension)
+                / dimensionClass.getDimensionValue(dimension));
+    }
+
+    /**
+     * Сложение двух вещественных чисел с размерностью.
+     */
+    @Override
+    public NumberWithDimension plus(NumberWithDimension other) {
+        return new NumberWithDimension(number + calculation(other), dimension, dimensionClass);
+    }
+
+    /**
+     * Вычитание двух вещественных чисел с размерностью.
+     */
+    @Override
+    public NumberWithDimension minus(NumberWithDimension other) {
+        return new NumberWithDimension(number - calculation(other), dimension, dimensionClass);
+    }
+
+    /**
+     * Умножение вещественного числа с размерностью на вещественное число.
+     */
+    @Override
+    public NumberWithDimension multiply(double multi) {
+        return new NumberWithDimension(number * multi, dimension, dimensionClass);
+    }
+
+    /**
+     * Деление вещественного числа с размерностью на вещественное число.
+     */
+    @Override
+    public NumberWithDimension divide(double div) {
+        return new NumberWithDimension(number / div, dimension, dimensionClass);
+    }
+
+    /**
+     * Деление двух вещественных чисел друг на друга. В результате получаем вещественное число.
+     */
+    @Override
+    public double divideForDim(NumberWithDimension other) {
+        return number / calculation(other);
+    }
+
+    /**
+     * Перевод вещественного числа с размерностью из одной размерности в другую.
+     */
+    @Override
+    public NumberWithDimension translate(String other) {
+        return new NumberWithDimension(number *
+                (dimensionClass.getDimensionValue(dimension) / dimensionClass.getDimensionValue(other)),
+                other, dimensionClass);
+    }
+
+    /**
+     * Сравнение двух вещественных чисел с размерностью.
+     */
+    @Override
+    public int compareTo(NumberWithDimension other) {
+        return (number ) > (calculation(other)) ? 1 : (number) == (calculation(other)) ? 0 : -1;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        NumberWithDimension numbers = (NumberWithDimension) o;
+
+        if (Double.compare(numbers.number, number) != 0) return false;
+        if (dimension != null ? !dimension.equals(numbers.dimension) : numbers.dimension != null) return false;
+        return dimensionClass != null ? dimensionClass.equals(numbers.dimensionClass) : numbers.dimensionClass == null;
+    }
+
+    @Override
+    public int hashCode() {
+        int result;
+        long temp;
+        temp = Double.doubleToLongBits(number);
+        result = (int) (temp ^ (temp >>> 32));
+        result = 31 * result + (dimension != null ? dimension.hashCode() : 0);
+        result = 31 * result + (dimensionClass != null ? dimensionClass.hashCode() : 0);
+        return result;
+    }
+
+    @Override
+    public String toString(){
+        return "" + number + " " + dimension;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/ru/spbstu/kspt/task1/NumberWithDimensionInterface.java b/src/main/java/ru/spbstu/kspt/task1/NumberWithDimensionInterface.java
new file mode 100644
index 0000000..65fe63a
--- /dev/null
+++ b/src/main/java/ru/spbstu/kspt/task1/NumberWithDimensionInterface.java
@@ -0,0 +1,36 @@
+package ru.spbstu.kspt.task1;
+
+interface NumberWithDimensionInterface {
+    /**
+     * Взятие вещественного числа из класса.
+     */
+    double getNumber(); //
+    /**
+     * Взятие размерности из класса в строковой форме.
+     */
+    String getDimension();
+    /**
+     * Сложение двух вещественных чисел с размерностью.
+     */
+    NumberWithDimension plus(NumberWithDimension other);
+    /**
+     * Вычитание двух вещественных чисел с размерностью.
+     */
+    NumberWithDimension minus(NumberWithDimension other);
+    /**
+     * Умножение числа с размерностью на вещественное число.
+     */
+    NumberWithDimension multiply(double multi);
+    /**
+     * Деление числа с размерностью на вещественное число.
+     */
+    NumberWithDimension divide(double div);
+    /**
+     * Деление числа с размерностью на другое число с размерностью.
+     */
+    double divideForDim(NumberWithDimension other);
+    /**
+     * Перевод числа с размерностью из одной величины в другую.
+     */
+    NumberWithDimension translate (String other);
+}
diff --git a/src/test/java/ru/spbstu/kspt/task1/DimensionsTest.java b/src/test/java/ru/spbstu/kspt/task1/DimensionsTest.java
new file mode 100644
index 0000000..668fad4
--- /dev/null
+++ b/src/test/java/ru/spbstu/kspt/task1/DimensionsTest.java
@@ -0,0 +1,26 @@
+package ru.spbstu.kspt.task1;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class DimensionsTest {
+    @Test
+    void getValueDimension() {
+        assertEquals(100000, new Dimensions().getLengthDimensions().getDimensionValue("км"));
+        assertEquals(1000000, new Dimensions().getWeightDimensions().getDimensionValue("кг"));
+        assertEquals(3600, new Dimensions().getTimeDimensions().getDimensionValue("ч"));
+        assertEquals(1, new Dimensions().getLengthDimensions().getDimensionValue("см"));
+        assertEquals(1000, new Dimensions().getWeightDimensions().getDimensionValue("г"));
+        assertEquals(60, new Dimensions().getTimeDimensions().getDimensionValue("мин"));
+        try {
+            assertEquals(60, new Dimensions().getTimeDimensions().getDimensionValue("оки"));
+            assertEquals(60, new Dimensions().getTimeDimensions().getDimensionValue("кауаку"));
+            assertEquals(60, new Dimensions().getTimeDimensions().getDimensionValue("минутки"));
+        }
+        catch (IllegalArgumentException e){
+            System.out.println("Ошибка поймана.");
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/src/test/java/ru/spbstu/kspt/task1/NumberWithDimensionTest.java b/src/test/java/ru/spbstu/kspt/task1/NumberWithDimensionTest.java
new file mode 100644
index 0000000..c5fc09c
--- /dev/null
+++ b/src/test/java/ru/spbstu/kspt/task1/NumberWithDimensionTest.java
@@ -0,0 +1,275 @@
+package ru.spbstu.kspt.task1;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class NumberWithDimensionTest {
+
+    private static final Logger logger = LogManager.getLogger(NumberWithDimensionTest.class);
+
+    @Test
+    void getNumber() {
+        assertEquals(2.0,
+                new NumberWithDimension(2.0,"км",  new Dimensions().getLengthDimensions())
+                        .getNumber());
+    }
+
+    @Test
+    void getDimension() {
+        assertEquals("км",
+                new NumberWithDimension(2.0,"км",  new Dimensions().getLengthDimensions())
+                        .getDimension());
+    }
+
+    @Test
+    void plus() {
+        logger.info("Начало теста на сложение с вещественным числом с размерностью, " +
+                "используя уже приготовленные размерности.");
+        assertEquals(new NumberWithDimension(4.0,"км",
+                        new Dimensions().getLengthDimensions()),
+                new NumberWithDimension(2.0,"км",
+                        new Dimensions().getLengthDimensions())
+                        .plus(new NumberWithDimension(2.0,"км",
+                                new Dimensions().getLengthDimensions())));
+        logger.info("Начало теста на сложение вещественного числа с размерностью, " +
+                "используя размерности, написанные пользователем.");
+        assertEquals(new NumberWithDimension(4.0,"А",
+                        new Dimensions()
+                                .addDimension("кА",1000)
+                                .addDimension("А",1)
+                                .addDimension("мА",0.001)),
+                new NumberWithDimension(2.0,"А",
+                        new Dimensions()
+                                .addDimension("кА",1000)
+                                .addDimension("А",1)
+                                .addDimension("мА",0.001))
+                        .plus(new NumberWithDimension(2.0,"А",
+                                new Dimensions()
+                                        .addDimension("кА",1000)
+                                        .addDimension("А",1)
+                                        .addDimension("мА",0.001))));
+        logger.info("Начало теста на сложение вещественного числа с размерностью, чтобы мы ловили ошибку.");
+        try {assertEquals(new NumberWithDimension(4.0,"км",
+                        new Dimensions().getLengthDimensions()),
+                new NumberWithDimension(2.0,"км",
+                        new Dimensions().getLengthDimensions())
+                        .plus(new NumberWithDimension(2.0,"км",
+                                new Dimensions().getWeightDimensions()))); }
+        catch (IllegalArgumentException e) {
+            System.out.println("Ошибка поймана.");
+        }
+        logger.info("Тест на сложение с вещественным числом с размерностью пройдены.");
+    }
+
+
+    @Test
+    void minus() {
+        logger.info("Начало теста на вычитание вещественного числа с размерностью, " +
+                "используя уже приготовленные размерности.");
+        assertEquals(new NumberWithDimension(4.0,"км",
+                        new Dimensions().getLengthDimensions()),
+                new NumberWithDimension(6.0,"км",
+                        new Dimensions().getLengthDimensions())
+                        .minus(new NumberWithDimension(2.0,"км",
+                                new Dimensions().getLengthDimensions())));
+        logger.info("Начало теста на вычитание вещественного числа с размерностью, " +
+                "используя размерности, написанные пользователем.");
+        assertEquals(new NumberWithDimension(5.0,"А",
+                        new Dimensions()
+                                .addDimension("кА",1000)
+                                .addDimension("А",1)
+                                .addDimension("мА",0.001)),
+                new NumberWithDimension(15.0,"А",
+                        new Dimensions()
+                                .addDimension("кА",1000)
+                                .addDimension("А",1)
+                                .addDimension("мА",0.001))
+                        .minus(new NumberWithDimension(10.0,"А",
+                                new Dimensions()
+                                        .addDimension("кА",1000)
+                                        .addDimension("А",1)
+                                        .addDimension("мА",0.001))));
+        logger.info("Начало теста на вычитание вещественного числа с размерностью, чтобы мы ловили ошибку.");
+        try {assertEquals(new NumberWithDimension(4.0,"км",
+                        new Dimensions().getLengthDimensions()),
+                new NumberWithDimension(2.0,"км",
+                        new Dimensions().getLengthDimensions())
+                        .minus(new NumberWithDimension(2.0,"км",
+                                new Dimensions().getWeightDimensions()))); }
+        catch (IllegalArgumentException e) {
+            System.out.println("Ошибка поймана.");
+        }
+        logger.info("Тест на вычитание с вещественным числом с размерностью пройдены.");
+    }
+
+    @Test
+    void multiply() {
+        logger.info("Начало теста на умножение на вещественное число, используя уже приготовленные размерности.");
+        assertEquals(new NumberWithDimension(26.0,"км",
+                        new Dimensions().getLengthDimensions()),
+                new NumberWithDimension(1.0,"км",
+                        new Dimensions().getLengthDimensions())
+                        .multiply(26.0));
+        assertEquals(new NumberWithDimension(29.0,"м",
+                        new Dimensions().getLengthDimensions()),
+                new NumberWithDimension(1.0,"м",
+                        new Dimensions().getLengthDimensions())
+                        .multiply(29.0));
+        logger.info("Начало теста на умножение на вещественное число, используя размерности, написанные пользователем.");
+        assertEquals(new NumberWithDimension(51.0,"А",
+                        new Dimensions()
+                                .addDimension("кА",1000)
+                                .addDimension("А",1)
+                                .addDimension("мА",0.001)),
+                new NumberWithDimension(2.0,"А",
+                        new Dimensions()
+                                .addDimension("кА",1000)
+                                .addDimension("А",1)
+                                .addDimension("мА",0.001))
+                        .multiply(25.5));
+        logger.info("Тест на умножение на вещественное число пройдены.");
+    }
+
+    @Test
+    void divide() {
+        logger.info("Начало теста на деление на вещественное число, используя уже приготовленные размерности.");
+        assertEquals(new NumberWithDimension(5.0,"км",
+                        new Dimensions().getLengthDimensions()),
+                new NumberWithDimension(25.0,"км",
+                        new Dimensions().getLengthDimensions())
+                        .divide(5.0));
+        assertEquals(new NumberWithDimension(5.0,"м",
+                        new Dimensions().getLengthDimensions()),
+                new NumberWithDimension(30.0,"м",
+                        new Dimensions().getLengthDimensions())
+                        .divide(6.0));
+        logger.info("Начало теста на деление на вещественное число, используя размерности, написанные пользователем.");
+        assertEquals(new NumberWithDimension(2.0,"А",
+                        new Dimensions()
+                                .addDimension("кА",1000)
+                                .addDimension("А",1)
+                                .addDimension("мА",0.001)),
+                new NumberWithDimension(12.0,"А",
+                        new Dimensions()
+                                .addDimension("кА",1000)
+                                .addDimension("А",1)
+                                .addDimension("мА",0.001))
+                        .divide(6.0));
+        logger.info("Тест на деление на вещественное число пройдены.");
+    }
+
+    @Test
+    void divideForDim() {
+        logger.info("Начало теста на деление на вещественное число с размерностью, " +
+                "используя уже приготовленные размерности.");
+        assertEquals(10.0,
+                new NumberWithDimension(25.0,"км",
+                        new Dimensions().getLengthDimensions())
+                        .divideForDim(new NumberWithDimension(2.5,"км",
+                                new Dimensions().getLengthDimensions())));
+        logger.info("Начало теста на деление на вещественное число с размерностью, " +
+                "используя размерности, написанные пользователем.");
+        assertEquals(5.5, new NumberWithDimension(11.0,"А",
+                        new Dimensions()
+                                .addDimension("кА",1000)
+                                .addDimension("А",1)
+                                .addDimension("мА",0.001))
+                        .divideForDim(new NumberWithDimension(2.0,"А",
+                                new Dimensions()
+                                        .addDimension("кА",1000)
+                                        .addDimension("А",1)
+                                        .addDimension("мА",0.001))));
+        logger.info("Начало теста на деление на вещественное число с размерностью, чтобы мы ловили ошибку.");
+        try {assertEquals(new NumberWithDimension(4.0,"км",
+                        new Dimensions().getLengthDimensions()),
+                new NumberWithDimension(2.0,"км",
+                        new Dimensions().getLengthDimensions())
+                        .divideForDim(new NumberWithDimension(2.0,"км",
+                                new Dimensions().getWeightDimensions()))); }
+        catch (IllegalArgumentException e) {
+            System.out.println("Ошибка поймана.");
+        }
+        logger.info("Тест на деление на вещественное число с размерностью пройдены.");
+    }
+
+    @Test
+    void translate() {
+        logger.info("Начало теста на перевод вещественного числа с размерностью, " +
+                "используя размерности, написанные пользователем.");
+        assertEquals(new NumberWithDimension(2000.0,"мА",
+                        new Dimensions()
+                                .addDimension("кА",1000)
+                                .addDimension("А",1)
+                                .addDimension("мА",0.001)),
+                new NumberWithDimension(2.0,"А",
+                        new Dimensions()
+                                .addDimension("кА",1000)
+                                .addDimension("А",1)
+                                .addDimension("мА",0.001))
+                        .translate("мА"));
+        logger.info("Начало теста на перевод вещественного числа с размерностью, " +
+                "используя уже приготовленные размерности.");
+        assertEquals(new NumberWithDimension(6000.0,"м",
+                        new Dimensions().getLengthDimensions()),
+                new NumberWithDimension(6.0,"км",
+                        new Dimensions().getLengthDimensions())
+                        .translate("м"));
+        logger.info("Начало теста на перевод вещественного числа с размерностью, чтобы мы ловили ошибку.");
+        try {assertEquals(new NumberWithDimension(4.0,"км",
+                        new Dimensions().getLengthDimensions()),
+                new NumberWithDimension(2.0,"км",
+                        new Dimensions().getLengthDimensions())
+                        .translate("glhf")); }
+        catch (IllegalArgumentException e) {
+            System.out.println("Ошибка поймана.");
+        }
+        logger.info("Тест на перевод чисел с размерностью пройдены.");
+    }
+
+
+    @Test
+    void compareTo() {
+        logger.info("Начало теста на сравнение между числами, используя уже приготовленные размерности.");
+        assertEquals(0,
+                new NumberWithDimension(25.0,"м",
+                        new Dimensions().getLengthDimensions())
+                        .compareTo(new NumberWithDimension(0.025,"км",
+                                new Dimensions().getLengthDimensions())));
+        assertEquals(1,
+                new NumberWithDimension(25.0,"м",
+                        new Dimensions().getLengthDimensions())
+                        .compareTo(new NumberWithDimension(0.024,"км",
+                                new Dimensions().getLengthDimensions())));
+        assertEquals(-1,
+                new NumberWithDimension(25.0,"м",
+                        new Dimensions().getLengthDimensions())
+                        .compareTo(new NumberWithDimension(0.026,"км",
+                                new Dimensions().getLengthDimensions())));
+        logger.info("Начало теста на сравнение между числами, используя размерности, написанные пользователем.");
+        assertEquals(1, new NumberWithDimension(2.0,"А",
+                        new Dimensions()
+                                .addDimension("кА",1000)
+                                .addDimension("А",1)
+                                .addDimension("мА",0.001))
+                        .compareTo(new NumberWithDimension(2.0,"мА",
+                                new Dimensions()
+                                        .addDimension("кА",1000)
+                                        .addDimension("А",1)
+                                        .addDimension("мА",0.001))));
+        logger.info("Начало теста на сравнение вещественных чисел с размерностью, чтобы мы ловили ошибку.");
+        try {assertEquals(new NumberWithDimension(4.0,"км",
+                        new Dimensions().getLengthDimensions()),
+                new NumberWithDimension(2.0,"км",
+                        new Dimensions().getLengthDimensions())
+                        .compareTo(new NumberWithDimension(2.0,"км",
+                                new Dimensions().getWeightDimensions()))); }
+        catch (IllegalArgumentException e) {
+            System.out.println("Ошибка поймана.");
+        }
+        logger.info("Тест на сравнение пройдены.");
+    }
+
+}
\ No newline at end of file