Skip to content

Commit c288710

Browse files
asap2Goasap2Go
committed
continued implementation of compu methods
1 parent 0aa6cd0 commit c288710

13 files changed

+473
-337
lines changed

‎a2l/coeffs.go

Lines changed: 33 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -7,23 +7,23 @@ import (
77
"github.com/rs/zerolog/log"
88
)
99

10-
type coeffs struct {
11-
a float64
12-
aSet bool
13-
b float64
14-
bSet bool
15-
c float64
16-
cSet bool
17-
d float64
18-
dSet bool
19-
e float64
20-
eSet bool
21-
f float64
22-
fSet bool
10+
type Coeffs struct {
11+
A float64
12+
ASet bool
13+
B float64
14+
BSet bool
15+
C float64
16+
CSet bool
17+
D float64
18+
DSet bool
19+
E float64
20+
ESet bool
21+
F float64
22+
FSet bool
2323
}
2424

25-
func parseCoeffs(tok *tokenGenerator) (coeffs, error) {
26-
co := coeffs{}
25+
func parseCoeffs(tok *tokenGenerator) (Coeffs, error) {
26+
co := Coeffs{}
2727
var err error
2828
forLoop:
2929
for {
@@ -36,65 +36,65 @@ forLoop:
3636
err = errors.New("unexpected token " + tok.current())
3737
log.Err(err).Msg("coeffs could not be parsed")
3838
break forLoop
39-
} else if !co.aSet {
39+
} else if !co.ASet {
4040
var buf float64
4141
buf, err = strconv.ParseFloat(tok.current(), 64)
4242
if err != nil {
4343
log.Err(err).Msg("coeffs a could not be parsed")
4444
break forLoop
4545
}
46-
co.a = buf
47-
co.aSet = true
46+
co.A = buf
47+
co.ASet = true
4848
log.Info().Msg("coeffs a successfully parsed")
49-
} else if !co.bSet {
49+
} else if !co.BSet {
5050
var buf float64
5151
buf, err = strconv.ParseFloat(tok.current(), 64)
5252
if err != nil {
5353
log.Err(err).Msg("coeffs b could not be parsed")
5454
break forLoop
5555
}
56-
co.b = buf
57-
co.bSet = true
56+
co.B = buf
57+
co.BSet = true
5858
log.Info().Msg("coeffs b successfully parsed")
59-
} else if !co.cSet {
59+
} else if !co.CSet {
6060
var buf float64
6161
buf, err = strconv.ParseFloat(tok.current(), 64)
6262
if err != nil {
6363
log.Err(err).Msg("coeffs c could not be parsed")
6464
break forLoop
6565
}
66-
co.c = buf
67-
co.cSet = true
66+
co.C = buf
67+
co.CSet = true
6868
log.Info().Msg("coeffs c successfully parsed")
69-
} else if !co.dSet {
69+
} else if !co.DSet {
7070
var buf float64
7171
buf, err = strconv.ParseFloat(tok.current(), 64)
7272
if err != nil {
7373
log.Err(err).Msg("coeffs d could not be parsed")
7474
break forLoop
7575
}
76-
co.d = buf
77-
co.dSet = true
76+
co.D = buf
77+
co.DSet = true
7878
log.Info().Msg("coeffs d successfully parsed")
79-
} else if !co.eSet {
79+
} else if !co.ESet {
8080
var buf float64
8181
buf, err = strconv.ParseFloat(tok.current(), 64)
8282
if err != nil {
8383
log.Err(err).Msg("coeffs e could not be parsed")
8484
break forLoop
8585
}
86-
co.e = buf
87-
co.eSet = true
86+
co.E = buf
87+
co.ESet = true
8888
log.Info().Msg("coeffs e successfully parsed")
89-
} else if !co.fSet {
89+
} else if !co.FSet {
9090
var buf float64
9191
buf, err = strconv.ParseFloat(tok.current(), 64)
9292
if err != nil {
9393
log.Err(err).Msg("coeffs f could not be parsed")
9494
break forLoop
9595
}
96-
co.f = buf
97-
co.fSet = true
96+
co.F = buf
97+
co.FSet = true
9898
log.Info().Msg("coeffs f successfully parsed")
9999
break forLoop
100100
}

‎a2l/coeffs_linear.go

Lines changed: 13 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -7,15 +7,15 @@ import (
77
"github.com/rs/zerolog/log"
88
)
99

10-
type coeffsLinear struct {
11-
a float64
12-
aSet bool
13-
b float64
14-
bSet bool
10+
type CoeffsLinear struct {
11+
A float64
12+
ASet bool
13+
B float64
14+
BSet bool
1515
}
1616

17-
func parseCoeffsLinear(tok *tokenGenerator) (coeffsLinear, error) {
18-
cl := coeffsLinear{}
17+
func parseCoeffsLinear(tok *tokenGenerator) (CoeffsLinear, error) {
18+
cl := CoeffsLinear{}
1919
var err error
2020
forLoop:
2121
for {
@@ -28,25 +28,25 @@ forLoop:
2828
err = errors.New("unexpected token " + tok.current())
2929
log.Err(err).Msg("coeffsLinear could not be parsed")
3030
break forLoop
31-
} else if !cl.aSet {
31+
} else if !cl.ASet {
3232
var buf float64
3333
buf, err = strconv.ParseFloat(tok.current(), 64)
3434
if err != nil {
3535
log.Err(err).Msg("coeffsLinear a could not be parsed")
3636
break forLoop
3737
}
38-
cl.a = buf
39-
cl.aSet = true
38+
cl.A = buf
39+
cl.ASet = true
4040
log.Info().Msg("coeffsLinear a successfully parsed")
41-
} else if !cl.bSet {
41+
} else if !cl.BSet {
4242
var buf float64
4343
buf, err = strconv.ParseFloat(tok.current(), 64)
4444
if err != nil {
4545
log.Err(err).Msg("coeffsLinear b could not be parsed")
4646
break forLoop
4747
}
48-
cl.b = buf
49-
cl.bSet = true
48+
cl.B = buf
49+
cl.BSet = true
5050
log.Info().Msg("coeffsLinear b successfully parsed")
5151
break forLoop
5252
}

‎a2l/compu_method.go

Lines changed: 40 additions & 115 deletions
Original file line numberDiff line numberDiff line change
@@ -2,87 +2,51 @@ package a2l
22

33
import (
44
"errors"
5-
"math"
65

76
"github.com/rs/zerolog/log"
87
)
98

10-
type compuMethod struct {
11-
name string
12-
nameSet bool
13-
longIdentifier string
14-
longIdentifierSet bool
15-
conversionType conversionTypeEnum
16-
conversionTypeSet bool
17-
format string
18-
formatSet bool
19-
unit string
20-
unitSet bool
21-
coeffs coeffs
22-
coeffsLinear coeffsLinear
23-
compuTabRef compuTabRef
24-
formula []Formula
25-
refUnit refUnit
26-
statusStringRef statusStringRef
9+
type CompuMethod struct {
10+
Name string
11+
NameSet bool
12+
LongIdentifier string
13+
LongIdentifierSet bool
14+
ConversionType conversionTypeEnum
15+
ConversionTypeSet bool
16+
Format string
17+
FormatSet bool
18+
Unit string
19+
UnitSet bool
20+
Coeffs Coeffs
21+
CoeffsLinear CoeffsLinear
22+
CompuTabRef CompuTabRef
23+
Formula []Formula
24+
RefUnit refUnit
25+
StatusStringRef StatusStringRef
2726
}
2827

29-
func (cm *compuMethod) convDecToPhy(dec float64) (float64, error) {
30-
var err error
31-
switch cm.conversionType {
32-
case Identical:
33-
return dec, nil
34-
case Form:
35-
//implement later.
36-
case Linear:
37-
if !(cm.coeffsLinear.aSet && cm.coeffsLinear.bSet) {
38-
err = errors.New("coeffsLinear not set in compuMethod: " + cm.name)
39-
log.Err(err).Msg("decimal value could not be converted")
40-
return 0, err
41-
}
42-
return cm.coeffsLinear.a*dec + cm.coeffsLinear.b, err
43-
case RatFunc:
44-
if !(cm.coeffs.aSet && cm.coeffs.bSet && cm.coeffs.cSet && cm.coeffs.dSet && cm.coeffs.eSet && cm.coeffs.fSet) {
45-
err = errors.New("coeffs not set in compuMethod: " + cm.name)
46-
log.Err(err).Msg("decimal value could not be converted")
47-
return 0, err
48-
}
49-
phy, err := cm.calcRatFunc(dec)
50-
if err != nil {
51-
log.Err(err).Msg("decimal value could not be converted")
52-
return phy, err
53-
}
54-
case TabIntp:
55-
case TabNointp:
56-
case TabVerb:
57-
default:
58-
err = errors.New("conversion Type undefined in compuMethod: " + cm.name)
59-
log.Err(err).Msg("decimal value could not be converted")
60-
return 0, err
61-
}
62-
}
63-
64-
func parseCompuMethod(tok *tokenGenerator) (compuMethod, error) {
65-
cm := compuMethod{}
28+
func parseCompuMethod(tok *tokenGenerator) (CompuMethod, error) {
29+
cm := CompuMethod{}
6630
var err error
6731
forLoop:
6832
for {
6933
switch tok.next() {
7034
case coeffsToken:
71-
cm.coeffs, err = parseCoeffs(tok)
35+
cm.Coeffs, err = parseCoeffs(tok)
7236
if err != nil {
7337
log.Err(err).Msg("compuMethod coeffs could not be parsed")
7438
break forLoop
7539
}
7640
log.Info().Msg("compuMethod coeffs successfully parsed")
7741
case coeffsLinearToken:
78-
cm.coeffsLinear, err = parseCoeffsLinear(tok)
42+
cm.CoeffsLinear, err = parseCoeffsLinear(tok)
7943
if err != nil {
8044
log.Err(err).Msg("compuMethod coeffsLinear could not be parsed")
8145
break forLoop
8246
}
8347
log.Info().Msg("compuMethod coeffsLinear successfully parsed")
8448
case compuTabRefToken:
85-
cm.compuTabRef, err = parseCompuTabRef(tok)
49+
cm.CompuTabRef, err = parseCompuTabRef(tok)
8650
if err != nil {
8751
log.Err(err).Msg("compuMethod compuTabRef could not be parsed")
8852
break forLoop
@@ -95,17 +59,17 @@ forLoop:
9559
log.Err(err).Msg("compuMethod formula could not be parsed")
9660
break forLoop
9761
}
98-
cm.formula = append(cm.formula, buf)
62+
cm.Formula = append(cm.Formula, buf)
9963
log.Info().Msg("compuMethod formula successfully parsed")
10064
case refUnitToken:
101-
cm.refUnit, err = parseRefUnit(tok)
65+
cm.RefUnit, err = parseRefUnit(tok)
10266
if err != nil {
10367
log.Err(err).Msg("compuMethod refUnit could not be parsed")
10468
break forLoop
10569
}
10670
log.Info().Msg("compuMethod refUnit successfully parsed")
10771
case statusStringRefToken:
108-
cm.statusStringRef, err = parseStatusStringRef(tok)
72+
cm.StatusStringRef, err = parseStatusStringRef(tok)
10973
if err != nil {
11074
log.Err(err).Msg("compuMethod statusStringRef could not be parsed")
11175
break forLoop
@@ -122,71 +86,32 @@ forLoop:
12286
err = errors.New("unedecpected token " + tok.current())
12387
log.Err(err).Msg("compuMethod could not be parsed")
12488
break forLoop
125-
} else if !cm.nameSet {
126-
cm.name = tok.current()
127-
cm.nameSet = true
89+
} else if !cm.NameSet {
90+
cm.Name = tok.current()
91+
cm.NameSet = true
12892
log.Info().Msg("compuMethod name successfully parsed")
129-
} else if !cm.longIdentifierSet {
130-
cm.longIdentifier = tok.current()
131-
cm.longIdentifierSet = true
93+
} else if !cm.LongIdentifierSet {
94+
cm.LongIdentifier = tok.current()
95+
cm.LongIdentifierSet = true
13296
log.Info().Msg("compuMethod longIdentifier successfully parsed")
133-
} else if !cm.conversionTypeSet {
134-
cm.conversionType, err = parseConversionTypeEnum(tok)
97+
} else if !cm.ConversionTypeSet {
98+
cm.ConversionType, err = parseConversionTypeEnum(tok)
13599
if err != nil {
136100
log.Err(err).Msg("compuMethod conversionType could not be parsed")
137101
break forLoop
138102
}
139-
cm.conversionTypeSet = true
103+
cm.ConversionTypeSet = true
140104
log.Info().Msg("compuMethod conversionType successfully parsed")
141-
} else if !cm.formatSet {
142-
cm.format = tok.current()
143-
cm.formatSet = true
105+
} else if !cm.FormatSet {
106+
cm.Format = tok.current()
107+
cm.FormatSet = true
144108
log.Info().Msg("compuMethod format successfully parsed")
145-
} else if !cm.unitSet {
146-
cm.unit = tok.current()
147-
cm.unitSet = true
109+
} else if !cm.UnitSet {
110+
cm.Unit = tok.current()
111+
cm.UnitSet = true
148112
log.Info().Msg("compuMethod unit successfully parsed")
149113
}
150114
}
151115
}
152116
return cm, err
153117
}
154-
155-
func (cm *compuMethod) calcRatFunc(dec float64) (float64, error) {
156-
//following formula defines f(Physical) = Decimal
157-
//y = (axx + bx + c) / (dxx + ex + f)
158-
//inverted fi(Decimal) = Physical
159-
//y = (e dec - b)/(2 (a - d dec)) ± sqrt((e dec - b)^2 - 4 (d dec - a) (f dec - c))/(2 (a - d dec))
160-
firstDivisor := (2 * (cm.coeffs.a - cm.coeffs.d*dec))
161-
if firstDivisor == 0 {
162-
err = errors.New("rationality function cannot be computed(zero divisor) for compuMethod: " + cm.name)
163-
log.Err(err).Msg("decimal value could not be converted")
164-
return 0, err
165-
}
166-
secondDivisorPositive := (2 * (cm.coeffs.a - cm.coeffs.d*dec)) +
167-
math.Sqrt(math.Pow((cm.coeffs.e*dec-cm.coeffs.b), 2)-4*(cm.coeffs.d*dec-cm.coeffs.a)*(cm.coeffs.f*dec-cm.coeffs.c))/firstDivisor
168-
secondDivisorNegative := (2 * (cm.coeffs.a - cm.coeffs.d*dec)) -
169-
math.Sqrt(math.Pow((cm.coeffs.e*dec-cm.coeffs.b), 2)-4*(cm.coeffs.d*dec-cm.coeffs.a)*(cm.coeffs.f*dec-cm.coeffs.c))/firstDivisor
170-
171-
if secondDivisorPositive != 0 && secondDivisorNegative != 0 {
172-
plusVal := (cm.coeffs.e*dec - cm.coeffs.b) / secondDivisorPositive
173-
minusVal := (cm.coeffs.e*dec - cm.coeffs.b) / secondDivisorNegative
174-
testVal := (cm.coeffs.a*plusVal*plusVal + cm.coeffs.b*plusVal + cm.coeffs.c) / (cm.coeffs.d*plusVal*plusVal + cm.coeffs.e*plusVal + cm.coeffs.f)
175-
if testVal == dec {
176-
return plusVal, err
177-
} else {
178-
return minusVal, err
179-
}
180-
} else if secondDivisorPositive != 0 {
181-
plusVal := (cm.coeffs.e*dec - cm.coeffs.b) / secondDivisorPositive
182-
return plusVal, err
183-
} else if secondDivisorNegative != 0 {
184-
minusVal := (cm.coeffs.e*dec - cm.coeffs.b) / secondDivisorNegative
185-
return minusVal, err
186-
} else {
187-
err = errors.New("rationality function cannot be computed(zero divisor) for compuMethod: " + cm.name)
188-
log.Err(err).Msg("decimal value could not be converted")
189-
return 0, err
190-
}
191-
192-
}

0 commit comments

Comments
 (0)