loom

1
/*
2
MIT License
3

4
Copyright (c) 2022 МГТУ им. Н.Э. Баумана, кафедра ИУ-6, Михаил Фетисов,
5

6
https://bmstu.codes/lsx/simodo/loom
7
*/
8

9
#include "simodo/variable/matrix_operations.h"
10
#include "simodo/bormental/DrBormental.h"
11
#include "simodo/inout/format/fmt.h"
12

13
#include <cmath>
14
#include <cassert>
15

16
namespace simodo::variable
17
{
18
    void minusMatrix(Value & matrix_value)
19
    {
20
        std::shared_ptr<Array> matrix = matrix_value.getArray();
21
        for(Value & v : matrix->values_mutable())
22
            if (v.isInt())
23
                v.setVariant(-v.getInt());
24
            else if (v.isFloat())
25
                v.setVariant(-v.getFloat());
26
            else if (!v.isNull())
27
                throw bormental::DrBormental("minusMatrix", 
28
                        inout::fmt("Invalid operation for a matrix element with type %1")
29
                        .arg(getValueTypeName(v.type())));
30
    }
31

32
    void additionMatrixMatrix(Value & matrix_value_1, const Value & matrix_value_2)
33
    {
34
        std::shared_ptr<Array> m1 = matrix_value_1.getArray();
35
        std::shared_ptr<Array> m2 = matrix_value_2.getArray();
36

37
        if (m1->values().size() != m2->values().size())
38
            throw bormental::DrBormental("additionMatrixMatrix", 
39
                    inout::fmt("Inconsistent dimension of matrices"));
40

41
        for(size_t i=0; i < m1->values().size(); ++i) {
42
            Value &       e1 = m1->values_mutable().at(i);
43
            const Value & e2 = m2->values_mutable().at(i);
44

45
            if (e2.isNull())
46
                e1.setVariant(e2.variant());
47
            else if (e1.isInt())
48
                e1.setVariant(e1.getInt() + e2.getInt());
49
            else if (e1.isFloat())
50
                e1.setVariant(e1.getFloat() + e2.getFloat());
51
            else if (!e1.isNull())
52
                throw bormental::DrBormental("additionMatrixMatrix", 
53
                        inout::fmt("Invalid operation for a matrix element with type %1")
54
                        .arg(getValueTypeName(e1.type())));
55
        }
56
    }
57

58
    void multiplicationMatrixScalar(Value & matrix_value, const Value & scalar_value)
59
    {
60
        std::shared_ptr<Array> matrix = matrix_value.getArray();
61
        for(Value & v : matrix->values_mutable())
62
            if (v.isInt())
63
                v.setVariant(v.getInt() * scalar_value.getInt());
64
            else if (v.isFloat())
65
                v.setVariant(v.getFloat() * scalar_value.getFloat());
66
            else if (!v.isNull())
67
                throw bormental::DrBormental("multiplicationMatrixScalar", 
68
                        inout::fmt("Invalid operation for a matrix element with type %1")
69
                        .arg(getValueTypeName(v.type())));
70
    }
71

72
    void multiplicationMatrixMatrix(Value & /*matrix_value_1*/, const Value & /*matrix_value_2*/)
73
    {
74
        throw bormental::DrBormental("multiplicationMatrixMatrix", 
75
                inout::fmt("Matrix multiplication operations are not supported"));
76
    }
77

78
    void inverseMatrix(Value & /*matrix_value*/)
79
    {
80
        throw bormental::DrBormental("inverseMatrix", 
81
                inout::fmt("Matrix reversal operations are not supported"));
82
    }
83

84
    double lengthVector(const Value & vector_value)
85
    {
86
        double                 res = 0;
87
        std::shared_ptr<Array> m   = vector_value.getArray();
88

89
        for(size_t i=0; i < m->values().size(); ++i) {
90
            Value &       e = m->values_mutable().at(i);
91

92
            if (e.isNull())
93
                return 0.0;
94
            else if (e.isInt())
95
                res += double(e.getInt() * e.getInt());
96
            else if (e.isFloat())
97
                res += e.getFloat() * e.getFloat();
98
            else 
99
                throw bormental::DrBormental("lengthVector", 
100
                        inout::fmt("Invalid operation for a vector element with type %1")
101
                        .arg(getValueTypeName(e.type())));
102
        }
103

104
        return std::sqrt(res);
105
    }
106

107
}