I'm attempting to reverse engineer an SVG animation in JavaScript to better understand the animation and I'm seeing the following SVG code representing an "Up" motion in JavaScript. However the SVG itself doesn't look like any typical SVG code I am used to using. Can you help identify how this SVG is structured? Or how I can adjust the follwing code so I can open it in an image editing software?
d 601 9aAaAaAnBkNnUaNaN"/D 18 10bAaAnAnBuXaN"/F 22 10W7AaAaBaEaGiAW-6NiNnXaNbUaNaNaN"/D 30 10bAaEuUnU"/D 114 10bAaAnAnBuXaN"/F 117 10W7AaAaBaBaAaGkAn0NkNnKaNaNaUaNaU"/D 125 10eAaGnAnUnUnU"/D 66 12eBnAnAnNnUaN"/F 70 12W6AaAaAbEaGkAn2NuKaNaUaNaNaNaN"/D 76 12gEuNnNnN"/D 593 12eBnAnAuKaN"/F 596 12eAaAeUbAnEbKeAnAbJnAiAxNxAkAnUaXnNbNaNaU"/D 604 13bEuK"/D 166 14eEnAkKaN"/D 608 14aAnN"/F 169 15eAeAaAaBaAaAnAnBn0NkNnNnKbNgNaU"/D 222 15aAbBaGxKnKaN"/D 175 16gEnAnUnNnN"/D 308 16aAaAaAaBuAnAnEaAaAaEnAuNnNuNnUnNaUbw-7bN"/D 314 16gAaGkNuX"/D 268 17eAaAaAaAaAaGnBnNuUuUaUiNaNaU"/D 501 17bAaAuAnAnKaN"/D 548 17eAnAnAnAnKaN"/F 552 17jEW-6AkNaNaNbN"/D 557 17gExK"/D 209 18bAaEeAaBnAuAeAW8NnNnKgGnBn1NkGaAuNnNnXaUnw-6aN"/F 216 18jAaEgAxEaAaAW-8NkNbNaUnNkUaAeK"/D 260 18eAaBnAuAnEaBnAnBeAaEnAkNnXnNnNnXaNbXaNaN"/D 364 18eAaBuNkNaN"/D 509 18bAaBnAaEnAeAaAaBnAaEnAxXaNuNuNW-8AnAuUaUaNbNW6AeKnNnUaN"/D 159 19bAaBaAaAeAa0UaNaNeGnAnAnAiNn3NnNnNnXaN"/F 213 19aAnN"/D 214 19bBkNaN"/D 356 19eAnAnAnAnBbNW9NeAaAbAaAaBaBnBkBxUnNaNeUaNnUuNW-9AkAnAnEaAeAaBnAkUkNnXaNaNaw-6aNaN"/D 460 19eAaBuAnNnK"/F 502 19W6BaAaEkNW-6AuAnUaUaNaNaN"/F 312 20gAgAnAnBnAaAaEaAaNaGuAkAW-7NuNnKaAbNaKnNnNnKaNaNbN"/F 358 20W8AbAaAkAW-9AuUaNaNaN"/D 403 20eBnBnNnK"/F 407 20jAbAaAaAaGnAkAW-8NnNnUaUaUaNaN"/D 412 20gEnNnNuN"/D 451 20gAnAnAnBnI"/F 455 20jBaAaEbNaNaGuAnAn1NnXaUaNaNaN"/D 551 20W6AeAaAaAaEnNuNuNW-9AuAnKaNaNeN"/F 557 20gAaBnNnNkN"/D 17 21jAW6NjAaAaBaw6nJnBnAxNnUnNaNbNaNaKnKnNnNW-8AuAnAnGaBbAaAbAnAuAuNnNnw-7nIaUaN"/D 113 21eAa0NeAaAaBaBnEuKnNuNW-7AuAnBnBnBaAaAeBnAnAxNnw-6nNnKaKaUaU"/F 263 21W8BnBbBnNuEbNaNbAaBnNuAnEaBnAW-9NaKnNkUaNaBeUnNnAnUnKaNbN"/D 320 21ew9uAnNnKnNnNaUaNaN"/F 511 21aAnN"/D 596 21gAgNjAbBaEaBnBnJnBuAuNnNnXaNbNbNbNnNnNnNnNkNW-8AuAuKaNeN"/D 65 22aAa2NeAaBaw6uUnUnNuNW-6AkAnAnAnBuw-6aUaN"/F 462 22bAuN"/D 462 23bAaAnAuK"/F 464 23aAnN"/F 512 23aEuNaU"/F 21 24W8AaAaEaEnAnAuAW-7NnNuUnXaNaNbN"/D 417 24aAaBaAnBnAiAW-9NuNnKaNaBaAaAW8NeNaX"/F 549 24W9AbAbAaBxAnBnAW-6NuNuUnKaNbN"/F 596 24W8AeAaAaAaAaAuAuAuAnExNuNuNnNnNnKnUbNbN"/F 71 25W6AbAaBaBaAnAnAnAkAiNkNnNnNnKaNaNaNeN"/F 119 25W7AbAaEaBnAuAnAkAxNkNnNnUaUaUaNbN"/D 265 25bAuN"/F 359 25W9AbBaAnBkAnAaBuAW-7NaUnNkNnKaNaNeN"/D 403 25aAnN"/D 449 25bGaAa1NaNbNaAbJnNuNW-6AW-8NnNnNnX"/D 269 26bAaAnAuK"/D 361 26bAuN"/D 365 26bAaAnAuK"/F 161 27a3AgGnBuAkAW-6NkNnNnXnNaN"/D 262 27aAaBkUaN"/D 357 27bAaBnAuUnNaN"/F 497 27aAnN"/F 211 28eAa1GnBnNnAkAxNkNnNaNnX"/F 500 28W8AbAbAnGkAW-6NuNnNnUnNbNaN"/D 592 28aEaAaAaAbEnAkNnNnw-8"/D 158 29eGaAuNuX"/D 272 29bAaAaAnAnAuNnKaN"/D 546 29aBbAbEnAuNnNnI"/D 559 29gJnAxNnUaUaN"/F 418 30aGuAkAW-8NuKW9NjN"/F 403 31aAnN"/F 460 31W6AbAuAuAxAiNuNnUW8N"/D 65 32aAaAaAeAnAnAuNuI"/D 81 32aGnBxNnUeNaNaN"/D 129 32aEnAnAxNnNeNaNbN"/D 177 32aw6uAuNnNnUeNbU"/F 275 32aAnN"/F 274 33aAnN"/D 222 34aBnAkUeN
Let's assume we have a vector and matrix like below:
r =: 100 + 5 5 $ i.25
r
100 101 102 103 104
105 106 107 108 109
110 111 112 113 114
115 116 117 118 119
120 121 122 123 124
v =: 100 + 5 $ i.5
v
100 101 102 103 104
Now I would like to have a way to interchange fragments as specified by selectors.
I know how I can exchange items:
(<0 _1) &C. v
104 101 102 103 100
here I interchanged element at index=0 and index=-1.
In case of matrix, the rows (items) are changed:
(<0 _1) &C. r
120 121 122 123 124
105 106 107 108 109
110 111 112 113 114
115 116 117 118 119
100 101 102 103 104
But what about if I want to specify two arbitrary selections. Example to what I am after:
sel1 =: (< (<0 1))
sel1 { v
100 101
sel2 =: (< (<2 3))
sel2 { v
102 103
sel1 sel2 INTERCHANGE v
102 103 100 101 104
And the same for matrix:
sel1 =: (< (<0 1),(<0 1))
sel1 { r
100 101
105 106
sel2 =: (< (<3 4),(<1 2))
sel2 { r
116 117
121 122
sel1 sel2 INTERCHANGE r
116 117 102 103 104
121 122 107 108 109
110 111 112 113 114
115 100 101 118 119
120 105 106 123 124
So my question would be how to define elegantly interchange that uses two selections?
I think that I would first create the two selections and then use Amend to swap them. May not be the most elegant or generalizable, but if you know the selections that you want to change and they are the same shape, it does work.
r
100 101 102 103 104
105 106 107 108 109
110 111 112 113 114
115 116 117 118 119
120 121 122 123 124
[rep=:((<3 4;1 2),(<0 1;0 1)) { r NB. rep is the selected replacement values
116 117
121 122
100 101
105 106
((<0 1;0 1),(<3 4;1 2)){ r NB. values that will be replaced (just a check that they are the same shape)
100 101
105 106
116 117
121 122
rep ((<0 1;0 1),(<3 4;1 2))} r NB. Select verb ({) changed to Amend adverb (})
116 117 102 103 104
121 122 107 108 109
110 111 112 113 114
115 100 101 118 119
120 105 106 123 124
I am using the following code in gnuplot to draw a tree from different inputs.
### tree diagram with gnuplot
reset session
#ID Parent Name Colors shape
# put datablock into strings
IDs = Parents = Names = Colors = Shape = ""
set table $Dummy
plot "tmp.dat" u (IDs = IDs.strcol(1)." "): \
(Parents = Parents.strcol(2)." "): \
(Names = Names.strcol(3)." "): \
(Colors = Colors.strcol(4)." "): \
(Shape = Shape.strcol(5)." ") w table
unset table
# Top node has no parent ID "NaN"
Start(n) = int(sum [i=1:words(Parents)] (word(Parents,i) eq "NaN" ? int(word(IDs,i)) : 0))
# get list index by ID
ItemIdx(s,n) = n == n ? (tmp=NaN, sum [i=1:words(s)] ((word(s,i)) == n ? (tmp=i,0) : 0), tmp) : NaN
# get parent of ID n
Parent(n) = word(Parents,ItemIdx(IDs,n))
# get level of ID n, recursive function
Level(n) = n == n ? Parent(n)>0 ? Level(Parent(n))-1 : 0 : NaN
# get number of children of ID n
ChildCount(n) = int(sum [i=1:words(Parents)] (word(Parents,i)==n))
# Create child list of ID n
ChildList(n) = (Ch = " ", sum [i=1:words(IDs)] (word(Parents,i)==n ? (Ch = Ch.word(IDs,i)." ",1) : (Ch,0) ), Ch )
# m-th child of ID n
Child(n,m) = word(ChildList(n),m)
# List of leaves, recursive function
LeafList(n) = (LL="", ChildCount(n)==0 ? LL=LL.n." " : sum [i=1:ChildCount(n)]
(LL=LL.LeafList(Child(n,i)), 0),LL)
# create list of all leaves
LeafAll = LeafList(Start(0))
# get x-position of ID n, recursive function
XPos(n) = ChildCount(n) == 0 ? ItemIdx(LeafAll,n) : (sum [i=1:ChildCount(n)](XPos(Child(n,i))))/(ChildCount(n))
# create the tree datablock for plotting
set print $Tree
do for [j=1:words(IDs)] {
n = int(word(IDs,j))
print sprintf("% 3d % 7.2f % 4d % 5s % 8s", n, XPos(n), Level(n), word(Names,j), word(Colors,j))
}
set print
print $Tree
# get x and y distance from ID n to its parent
dx(n) = XPos(Parent(int(n))) - XPos(int(n))
dy(n) = Level(Parent(int(n))) - Level(int(n))
unset border
unset tics
set offsets 0.25, 0.25, 0.25, 0.25
array shape[words(IDs)] # pointtype 6 = circle, pointtype 4 = square
array color[words(IDs)]
do for [i=1:words(IDs)] {
color[i] = int(word(Colors,i))
shape[i] = int(word(Shape,i))
print sprintf("color[%2d] = %d",i,color[i])
}
plot $Tree u 2:3:(dx($1)):(dy($1)) w vec nohead ls -1 not,\
"" u 2:3:(shape[$1]+1):(color[$1]) w p pt variable ps 6 lc rgb variable not, \
"" u 2:3:(shape[$1]) w p pt variable ps 6 lw 1.5 lc rgb "black" not, \
"" u 2:3:4 w labels offset 0,0.1 center not
### end of code
for a small dataset like this one, the output works perfect
1 2.00 0 y_{45} 0xFE1034
2 1.00 -1 - 0x118C4B
3 2.99 -1 y_{37} 0xFE1034
4 2.00 -2 - 0xC6C1C1
5 3.98 -2 y_{13} 0xFE1034
6 3.00 -3 - 0x118C4B
7 4.97 -3 y_{14} 0xFE1034
8 4.00 -4 - 0x118C4B
9 5.94 -4 y_{20} 0xFE1034
10 5.00 -5 - 0xC6C1C1
11 6.88 -5 y_{27} 0xFE1034
12 6.00 -6 - 0xC6C1C1
13 7.75 -6 y_{41} 0xFE1034
14 7.00 -7 - 0xC6C1C1
15 8.50 -7 y_{54} 0xFE1034
16 8.00 -8 - 0xC6C1C1
17 9.00 -8 - 0xC6C1C1
But, for larger datasets the tree becomes cramped, the nodes overlap, and looks ugly.
Moreover, when there are more than a few hundred nodes like below, I get a stack overflow error and the plot does not appear. The error comes from this line
LeafAll = LeafList(Start(0))
Any help with this will be appreciated.
1 NaN y_{295} 0xFE1034 6
2 1 x_{0} 0x33B2FF 6
3 1 y_{1285} 0xFE1034 6
4 2 - 0xC6C1C1 8
5 2 - 0xC6C1C1 8
6 3 x_{3} 0x33B2FF 6
7 3 y_{18} 0xFE1034 6
8 6 - 0xC6C1C1 8
9 6 - 0xC6C1C1 8
10 7 x_{13} 0x33B2FF 6
11 7 y_{21} 0xFE1034 6
12 10 - 0xC6C1C1 8
13 10 - 0xC6C1C1 8
14 11 x_{10} 0x33B2FF 6
15 11 y_{50} 0xFE1034 6
16 14 - 0xC6C1C1 8
17 14 - 0xC6C1C1 8
18 15 - 0x118C4B 4
19 15 y_{62} 0xFE1034 6
20 19 - 0xC6C1C1 8
21 19 y_{48} 0xFE1034 6
22 21 x_{41} 0x33B2FF 6
23 21 y_{1839} 0xFE1034 6
24 22 - 0xC6C1C1 8
25 22 - 0xC6C1C1 8
26 23 - 0xC6C1C1 8
27 23 y_{44} 0xFE1034 6
28 27 x_{12} 0x33B2FF 6
29 27 y_{15} 0xFE1034 6
30 28 - 0xC6C1C1 8
31 28 - 0xC6C1C1 8
32 29 x_{58} 0x33B2FF 6
33 29 y_{127} 0xFE1034 6
34 32 - 0xC6C1C1 8
35 32 - 0xC6C1C1 8
36 33 - 0xC6C1C1 8
37 33 y_{60} 0xFE1034 6
38 37 - 0xC6C1C1 8
39 37 y_{1825} 0xFE1034 6
40 39 - 0xC6C1C1 8
41 39 y_{1878} 0xFE1034 6
42 41 - 0xC6C1C1 8
43 41 y_{33} 0xFE1034 6
44 43 - 0xC6C1C1 8
45 43 y_{3} 0xFE1034 6
46 45 - 0xC6C1C1 8
47 45 y_{1435} 0xFE1034 6
48 47 - 0xC6C1C1 8
49 47 y_{218} 0xFE1034 6
50 49 - 0xC6C1C1 8
51 49 y_{20} 0xFE1034 6
52 51 - 0xC6C1C1 8
53 51 y_{13} 0xFE1034 6
54 53 - 0xC6C1C1 8
55 53 y_{47} 0xFE1034 6
56 55 - 0xC6C1C1 8
57 55 y_{2321} 0xFE1034 6
58 57 - 0xC6C1C1 8
59 57 y_{28} 0xFE1034 6
60 59 - 0xC6C1C1 8
61 59 y_{52} 0xFE1034 6
62 61 - 0xC6C1C1 8
63 61 y_{2410} 0xFE1034 6
64 63 - 0xC6C1C1 8
65 63 y_{1751} 0xFE1034 6
66 65 - 0xC6C1C1 8
67 65 y_{186} 0xFE1034 6
68 67 - 0xC6C1C1 8
69 67 y_{1850} 0xFE1034 6
70 69 - 0xC6C1C1 8
71 69 y_{491} 0xFE1034 6
72 71 - 0xC6C1C1 8
73 71 y_{23} 0xFE1034 6
74 73 - 0xC6C1C1 8
75 73 y_{0} 0xFE1034 6
76 75 x_{52} 0x33B2FF 6
77 75 y_{1110} 0xFE1034 6
78 76 - 0xC6C1C1 8
79 76 - 0xC6C1C1 8
80 77 - 0xC6C1C1 8
81 77 y_{57} 0xFE1034 6
82 81 - 0xC6C1C1 8
83 81 y_{12} 0xFE1034 6
84 83 - 0xC6C1C1 8
85 83 y_{1269} 0xFE1034 6
86 85 - 0xC6C1C1 8
87 85 y_{1278} 0xFE1034 6
88 87 - 0x118C4B 4
89 87 y_{63} 0xFE1034 6
90 89 - 0xC6C1C1 8
91 89 y_{1338} 0xFE1034 6
92 91 - 0xC6C1C1 8
93 91 y_{1271} 0xFE1034 6
94 93 - 0xC6C1C1 8
95 93 y_{41} 0xFE1034 6
96 95 - 0xC6C1C1 8
97 95 y_{65} 0xFE1034 6
98 97 - 0x118C4B 4
99 97 y_{1630} 0xFE1034 6
100 99 - 0xC6C1C1 8
101 99 y_{2068} 0xFE1034 6
102 101 - 0xC6C1C1 8
103 101 y_{2532} 0xFE1034 6
104 103 - 0xC6C1C1 8
105 103 y_{1760} 0xFE1034 6
106 105 - 0xC6C1C1 8
107 105 y_{188} 0xFE1034 6
108 107 - 0xC6C1C1 8
109 107 y_{2405} 0xFE1034 6
110 109 - 0xC6C1C1 8
111 109 y_{1867} 0xFE1034 6
112 111 - 0xC6C1C1 8
113 111 y_{1482} 0xFE1034 6
114 113 - 0xC6C1C1 8
115 113 y_{79} 0xFE1034 6
116 115 - 0xC6C1C1 8
117 115 y_{11} 0xFE1034 6
118 117 - 0xC6C1C1 8
119 117 y_{5226} 0xFE1034 6
120 119 - 0xC6C1C1 8
121 119 y_{354} 0xFE1034 6
122 121 - 0xC6C1C1 8
123 121 y_{2748} 0xFE1034 6
124 123 - 0xC6C1C1 8
125 123 y_{27} 0xFE1034 6
126 125 - 0xC6C1C1 8
127 125 y_{426} 0xFE1034 6
128 127 - 0xC6C1C1 8
129 127 y_{12571} 0xFE1034 6
130 129 - 0xC6C1C1 8
131 129 y_{5089} 0xFE1034 6
132 131 - 0xC6C1C1 8
133 131 y_{2490} 0xFE1034 6
134 133 - 0xC6C1C1 8
135 133 y_{1752} 0xFE1034 6
136 135 - 0xC6C1C1 8
137 135 y_{1874} 0xFE1034 6
138 137 - 0xC6C1C1 8
139 137 y_{370} 0xFE1034 6
140 139 - 0xC6C1C1 8
141 139 y_{1453} 0xFE1034 6
142 141 - 0xC6C1C1 8
143 141 y_{2756} 0xFE1034 6
144 143 - 0xC6C1C1 8
145 143 y_{545} 0xFE1034 6
146 145 - 0xC6C1C1 8
147 145 y_{36} 0xFE1034 6
148 147 - 0xC6C1C1 8
149 147 y_{2409} 0xFE1034 6
150 149 - 0xC6C1C1 8
151 149 y_{96} 0xFE1034 6
152 151 - 0xC6C1C1 8
153 151 y_{82} 0xFE1034 6
154 153 - 0xC6C1C1 8
155 153 y_{1788} 0xFE1034 6
156 155 - 0xC6C1C1 8
157 155 y_{2812} 0xFE1034 6
158 157 - 0xC6C1C1 8
159 157 y_{10357} 0xFE1034 6
160 159 - 0xC6C1C1 8
161 159 y_{1801} 0xFE1034 6
162 161 - 0xC6C1C1 8
163 161 y_{55} 0xFE1034 6
164 163 - 0xC6C1C1 8
165 163 y_{2868} 0xFE1034 6
166 165 - 0xC6C1C1 8
167 165 y_{453} 0xFE1034 6
168 167 - 0xC6C1C1 8
169 167 y_{31} 0xFE1034 6
170 169 - 0xC6C1C1 8
171 169 y_{1281} 0xFE1034 6
172 171 - 0xC6C1C1 8
173 171 y_{17} 0xFE1034 6
174 173 - 0xC6C1C1 8
175 173 y_{1748} 0xFE1034 6
176 175 - 0xC6C1C1 8
177 175 y_{58} 0xFE1034 6
178 177 - 0xC6C1C1 8
179 177 y_{2420} 0xFE1034 6
180 179 - 0xC6C1C1 8
181 179 y_{7128} 0xFE1034 6
182 181 - 0xC6C1C1 8
183 181 y_{11164} 0xFE1034 6
184 183 - 0xC6C1C1 8
185 183 y_{1820} 0xFE1034 6
186 185 - 0xC6C1C1 8
187 185 y_{1713} 0xFE1034 6
188 187 - 0xC6C1C1 8
189 187 y_{387} 0xFE1034 6
190 189 - 0xC6C1C1 8
191 189 y_{5253} 0xFE1034 6
192 191 - 0xC6C1C1 8
193 191 y_{1699} 0xFE1034 6
194 193 - 0xC6C1C1 8
195 193 - 0xC6C1C1 8
The depth of gnuplot's evaluation stack is capped at at 250 to prevent run-away recursion. In order to increase that you would have to edit the source and recompile the program. If you really want to do that, the relevant definition is here:
[gnuplot-5.2.8/src] grep -n -A 3 -B 3 STACK_DEPTH eval.h
44-
45-#include <stdio.h> /* for FILE* */
46-
47:#define STACK_DEPTH 250 /* maximum size of the execution stack */
48-#define MAX_AT_LEN 150 /* max number of entries in action table */
49-
50-/* These are used by add_action() to index the subroutine list ft[] in eval.c */
I have not looked at your recursion algorithm very closely, but I would think it possible to re-order the evaluation so that the subtree information is computed bottom-up rather than top-down. In that direction it may become purely an iteration rather than a recursive descent.
On the other hand you also say that larger trees don't fit into a single plot. So another approach may be to split the tree at a depth that both fits on the page and doesn't exceed the stack depth. Then you restart the process over again for each node that was truncated, and mark that node with an arrow or annotation or other indication like "subtree continued in figure 1b". Here I have hand-mangled your large figure to show the idea
I am using sns.lineplot to show the confidence intervals in a plot.
sns.lineplot(x = threshold, y = mrl_array, err_style = 'band', ci=95)
plt.show()
I'm getting the following plot, which doesn't show the confidence interval:
What's the problem?
There is probably only a single observation per x value.
If there is only one observation per x value, then there is no confidence interval to plot.
Bootstrapping is performed per x value, but there needs to be more than one obsevation for this to take effect.
ci: Size of the confidence interval to draw when aggregating with an estimator. 'sd' means to draw the standard deviation of the data. Setting to None will skip bootstrapping.
Note the following examples from seaborn.lineplot.
This is also the case for sns.relplot with kind='line'.
The question specifies sns.lineplot, but this answer applies to any seaborn plot that displays a confidence interval, such as seaborn.barplot.
Data
import seaborn as sns
# load data
flights = sns.load_dataset("flights")
year month passengers
0 1949 Jan 112
1 1949 Feb 118
2 1949 Mar 132
3 1949 Apr 129
4 1949 May 121
# only May flights
may_flights = flights.query("month == 'May'")
year month passengers
4 1949 May 121
16 1950 May 125
28 1951 May 172
40 1952 May 183
52 1953 May 229
64 1954 May 234
76 1955 May 270
88 1956 May 318
100 1957 May 355
112 1958 May 363
124 1959 May 420
136 1960 May 472
# standard deviation for each year of May data
may_flights.set_index('year')[['passengers']].std(axis=1)
year
1949 NaN
1950 NaN
1951 NaN
1952 NaN
1953 NaN
1954 NaN
1955 NaN
1956 NaN
1957 NaN
1958 NaN
1959 NaN
1960 NaN
dtype: float64
# flight in wide format
flights_wide = flights.pivot("year", "month", "passengers")
month Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec
year
1949 112 118 132 129 121 135 148 148 136 119 104 118
1950 115 126 141 135 125 149 170 170 158 133 114 140
1951 145 150 178 163 172 178 199 199 184 162 146 166
1952 171 180 193 181 183 218 230 242 209 191 172 194
1953 196 196 236 235 229 243 264 272 237 211 180 201
1954 204 188 235 227 234 264 302 293 259 229 203 229
1955 242 233 267 269 270 315 364 347 312 274 237 278
1956 284 277 317 313 318 374 413 405 355 306 271 306
1957 315 301 356 348 355 422 465 467 404 347 305 336
1958 340 318 362 348 363 435 491 505 404 359 310 337
1959 360 342 406 396 420 472 548 559 463 407 362 405
1960 417 391 419 461 472 535 622 606 508 461 390 432
# standard deviation for each year
flights_wide.std(axis=1)
year
1949 13.720147
1950 19.070841
1951 18.438267
1952 22.966379
1953 28.466887
1954 34.924486
1955 42.140458
1956 47.861780
1957 57.890898
1958 64.530472
1959 69.830097
1960 77.737125
dtype: float64
Plots
may_flights has one observation per year, so no CI is shown.
sns.lineplot(data=may_flights, x="year", y="passengers")
sns.barplot(data=may_flights, x='year', y='passengers')
flights_wide shows there are twelve observations for each year, so the CI shows when all of flights is plotted.
sns.lineplot(data=flights, x="year", y="passengers")
sns.barplot(data=flights, x='year', y='passengers')
I am working in excel using SUMIF formula, my data is as follows:
Region Opr Qty Cost Combo(col B&A)
192 114 50 500 104192
192 104 453 548 104192
192 114 125 54654 114192
192 114 155 1545 114192
192 124 12 1553 124192
192 134 12222 1554545 134192
192 174 256 15478 174192
192 104 12 1555 104192
192 104 210 1156 104192
192 114 47 448953 114192
192 114 29 59479 114192
192 124 124 32451 124192
192 134 114 290240 134192
4192 10 210 115656 104192
4192 10 47 44896 104192
4192 11 29 12866 114192
4192 11 549 290240 114192
4192 12 124 59480 124192
4192 13 114 61343 134192
4192 17 310 45339 174192
4192 10 56 32451 104192
4192 10 103 82483 104192
4192 11 685 111380 114192
4192 11 646 201858 114192
4192 12 26 6489 124192
4192 13 87 44543 134192
If you see the last column it's giving same combination result but the operator and region are not always the same. I want to do SUMIF against Region which is throwing wrong values.
You can try SUMPRODUCT:
=SUMPRODUCT(((B2:B27&A2:A27)*1<>E2:E27)*1)
If the concatenation of column B to A is not equal to the Combo, count as 1, then add all the 1 together in SUMPRODUCT.
Change the range accordingly.
The *1 convert any text to number.