Coverage for gpkit/solution_array.py: 73%

1"""Defines SolutionArray class""" 

2import sys 

3import re 

4import json 

5import difflib 

6from operator import sub 

7import warnings as pywarnings 

8import pickle 

9import gzip 

10import pickletools 

11from collections import defaultdict 

12import numpy as np 

13from .nomials import NomialArray 

14from .small_classes import DictOfLists, Strings, SolverLog 

15from .small_scripts import mag, try_str_without 

16from .repr_conventions import unitstr, lineagestr, UNICODE_EXPONENTS 

17from .breakdowns import Breakdowns 

18 

19 

20CONSTRSPLITPATTERN = re.compile(r"([^*]\*[^*])|( \+ )|( >= )|( <= )|( = )") 

21 

22VALSTR_REPLACES = [ 

23 ("+nan", " nan"), 

24 ("-nan", " nan"), 

25 ("nan%", "nan "), 

26 ("nan", " - "), 

27] 

28 

29 

30class SolSavingEnvironment: 

31 """Temporarily removes construction/solve attributes from constraints. 

32 

33 This approximately halves the size of the pickled solution. 

34 """ 

35 

36 def __init__(self, solarray, saveconstraints): 

37 self.solarray = solarray 

38 self.attrstore = {} 

39 self.saveconstraints = saveconstraints 

40 self.constraintstore = None 

41 

42 

43 def __enter__(self): 

44 if "sensitivities" not in self.solarray: 

45 pass 

46 elif self.saveconstraints: 

47 for constraint_attr in ["bounded", "meq_bounded", "vks", 

48 "v_ss", "unsubbed", "varkeys"]: 

49 store = {} 

50 for constraint in self.solarray["sensitivities"]["constraints"]: 

51 if getattr(constraint, constraint_attr, None): 

52 store[constraint] = getattr(constraint, constraint_attr) 

53 delattr(constraint, constraint_attr) 

54 self.attrstore[constraint_attr] = store 

55 else: 

56 self.constraintstore = \ 

57 self.solarray["sensitivities"].pop("constraints") 

58 

59 def __exit__(self, type_, val, traceback): 

60 if not self.constraintstore: 

61 pass 

62 elif self.saveconstraints: 

63 for constraint_attr, store in self.attrstore.items(): 

64 for constraint, value in store.items(): 

65 setattr(constraint, constraint_attr, value) 

66 else: 

67 self.solarray["sensitivities"]["constraints"] = self.constraintstore 

68 

69def msenss_table(data, _, **kwargs): 

70 "Returns model sensitivity table lines" 

71 if "models" not in data.get("sensitivities", {}): 

72 return "" 

73 data = sorted(data["sensitivities"]["models"].items(), 

74 key=lambda i: ((i[1] < 0.1).all(), 

75 -np.max(i[1]) if (i[1] < 0.1).all() 

76 else -round(np.mean(i[1]), 1), i[0])) 

77 lines = ["Model Sensitivities", "-------------------"] 

78 if kwargs["sortmodelsbysenss"]: 

79 lines[0] += " (sorts models in sections below)" 

80 previousmsenssstr = "" 

81 for model, msenss in data: 

82 if not model: # for now let's only do named models 

83 continue 

84 if (msenss < 0.1).all(): 

85 msenss = np.max(msenss) 

86 if msenss: 

87 msenssstr = "%6s" % ("<1e%i" % max(-3, np.log10(msenss))) 

88 else: 

89 msenssstr = " =0 " 

90 else: 

91 meansenss = round(np.mean(msenss), 1) 

92 msenssstr = "%+6.1f" % meansenss 

93 deltas = msenss - meansenss 

94 if np.max(np.abs(deltas)) > 0.1: 

95 deltastrs = ["%+4.1f" % d if abs(d) >= 0.1 else " - " 

96 for d in deltas] 

97 msenssstr += " + [ %s ]" % " ".join(deltastrs) 

98 if msenssstr == previousmsenssstr: 

99 msenssstr = " "*len(msenssstr) 

100 else: 

101 previousmsenssstr = msenssstr 

102 lines.append("%s : %s" % (msenssstr, model)) 

103 return lines + [""] if len(lines) > 3 else [] 

104 

105 

106def senss_table(data, showvars=(), title="Variable Sensitivities", **kwargs): 

107 "Returns sensitivity table lines" 

108 if "variables" in data.get("sensitivities", {}): 

109 data = data["sensitivities"]["variables"] 

110 if showvars: 

111 data = {k: data[k] for k in showvars if k in data} 

112 return var_table(data, title, sortbyvals=True, skipifempty=True, 

113 valfmt="%+-.2g ", vecfmt="%+-8.2g", 

114 printunits=False, minval=1e-3, **kwargs) 

115 

116 

117def topsenss_table(data, showvars, nvars=5, **kwargs): 

118 "Returns top sensitivity table lines" 

119 data, filtered = topsenss_filter(data, showvars, nvars) 

120 title = "Most Sensitive Variables" 

121 if filtered: 

122 title = "Next Most Sensitive Variables" 

123 return senss_table(data, title=title, hidebelowminval=True, **kwargs) 

124 

125 

126def topsenss_filter(data, showvars, nvars=5): 

127 "Filters sensitivities down to top N vars" 

128 if "variables" in data.get("sensitivities", {}): 

129 data = data["sensitivities"]["variables"] 

130 mean_abs_senss = {k: np.abs(s).mean() for k, s in data.items() 

131 if not np.isnan(s).any()} 

132 topk = [k for k, _ in sorted(mean_abs_senss.items(), key=lambda l: l[1])] 

133 filter_already_shown = showvars.intersection(topk) 

134 for k in filter_already_shown: 

135 topk.remove(k) 

136 if nvars > 3: # always show at least 3 

137 nvars -= 1 

138 return {k: data[k] for k in topk[-nvars:]}, filter_already_shown 

139 

140 

141def insenss_table(data, _, maxval=0.1, **kwargs): 

142 "Returns insensitivity table lines" 

143 if "constants" in data.get("sensitivities", {}): 

144 data = data["sensitivities"]["variables"] 

145 data = {k: s for k, s in data.items() if np.mean(np.abs(s)) < maxval} 

146 return senss_table(data, title="Insensitive Fixed Variables", **kwargs) 

147 

148 

149def tight_table(self, _, ntightconstrs=5, tight_senss=1e-2, **kwargs): 

150 "Return constraint tightness lines" 

151 title = "Most Sensitive Constraints" 

152 if len(self) > 1: 

153 title += " (in last sweep)" 

154 data = sorted(((-float("%+6.2g" % abs(s[-1])), str(c)), 

155 "%+6.2g" % abs(s[-1]), id(c), c) 

156 for c, s in self["sensitivities"]["constraints"].items() 

157 if s[-1] >= tight_senss)[:ntightconstrs] 

158 else: 

159 data = sorted(((-float("%+6.2g" % abs(s)), str(c)), 

160 "%+6.2g" % abs(s), id(c), c) 

161 for c, s in self["sensitivities"]["constraints"].items() 

162 if s >= tight_senss)[:ntightconstrs] 

163 return constraint_table(data, title, **kwargs) 

164 

165def loose_table(self, _, min_senss=1e-5, **kwargs): 

166 "Return constraint tightness lines" 

167 title = "Insensitive Constraints |below %+g|" % min_senss 

168 if len(self) > 1: 

169 title += " (in last sweep)" 

170 data = [(0, "", id(c), c) 

171 for c, s in self["sensitivities"]["constraints"].items() 

172 if s[-1] <= min_senss] 

173 else: 

174 data = [(0, "", id(c), c) 

175 for c, s in self["sensitivities"]["constraints"].items() 

176 if s <= min_senss] 

177 return constraint_table(data, title, **kwargs) 

178 

179 

180# pylint: disable=too-many-branches,too-many-locals,too-many-statements 

181def constraint_table(data, title, sortbymodel=True, showmodels=True, **_): 

182 "Creates lines for tables where the right side is a constraint." 

183 # TODO: this should support 1D array inputs from sweeps 

184 excluded = {"units"} if showmodels else {"units", "lineage"} 

185 models, decorated = {}, [] 

186 for sortby, openingstr, _, constraint in sorted(data): 

187 model = lineagestr(constraint) if sortbymodel else "" 

188 if model not in models: 

189 models[model] = len(models) 

190 constrstr = try_str_without( 

191 constraint, {":MAGIC:"+lineagestr(constraint)}.union(excluded)) 

192 if " at 0x" in constrstr: # don't print memory addresses 

193 constrstr = constrstr[:constrstr.find(" at 0x")] + ">" 

194 decorated.append((models[model], model, sortby, constrstr, openingstr)) 

195 decorated.sort() 

196 previous_model, lines = None, [] 

197 for varlist in decorated: 

198 _, model, _, constrstr, openingstr = varlist 

199 if model != previous_model: 

200 if lines: 

201 lines.append(["", ""]) 

202 if model or lines: 

203 lines.append([("newmodelline",), model]) 

204 previous_model = model 

205 minlen, maxlen = 25, 80 

206 segments = [s for s in CONSTRSPLITPATTERN.split(constrstr) if s] 

207 constraintlines = [] 

208 line = "" 

209 next_idx = 0 

210 while next_idx < len(segments): 

211 segment = segments[next_idx] 

212 next_idx += 1 

213 if CONSTRSPLITPATTERN.match(segment) and next_idx < len(segments): 

214 segments[next_idx] = segment[1:] + segments[next_idx] 

215 segment = segment[0] 

216 elif len(line) + len(segment) > maxlen and len(line) > minlen: 

217 constraintlines.append(line) 

218 line = " " # start a new line 

219 line += segment 

220 while len(line) > maxlen: 

221 constraintlines.append(line[:maxlen]) 

222 line = " " + line[maxlen:] 

223 constraintlines.append(line) 

224 lines += [(openingstr + " : ", constraintlines[0])] 

225 lines += [("", l) for l in constraintlines[1:]] 

226 if not lines: 

227 lines = [("", "(none)")] 

228 maxlens = np.max([list(map(len, line)) for line in lines 

229 if line[0] != ("newmodelline",)], axis=0) 

230 dirs = [">", "<"] # we'll check lengths before using zip 

231 assert len(list(dirs)) == len(list(maxlens)) 

232 fmts = ["{0:%s%s}" % (direc, L) for direc, L in zip(dirs, maxlens)] 

233 for i, line in enumerate(lines): 

234 if line[0] == ("newmodelline",): 

235 linelist = [fmts[0].format(" | "), line[1]] 

236 else: 

237 linelist = [fmt.format(s) for fmt, s in zip(fmts, line)] 

238 lines[i] = "".join(linelist).rstrip() 

239 return [title] + ["-"*len(title)] + lines + [""] 

240 

241 

242def warnings_table(self, _, **kwargs): 

243 "Makes a table for all warnings in the solution." 

244 title = "WARNINGS" 

245 lines = ["~"*len(title), title, "~"*len(title)] 

246 if "warnings" not in self or not self["warnings"]: 

247 return [] 

248 for wtype in sorted(self["warnings"]): 

249 data_vec = self["warnings"][wtype] 

250 if len(data_vec) == 0: 

251 continue 

252 if not hasattr(data_vec, "shape"): 

253 data_vec = [data_vec] # not a sweep 

254 else: 

255 all_equal = True 

256 for data in data_vec[1:]: 

257 eq_i = (data == data_vec[0]) 

258 if hasattr(eq_i, "all"): 

259 eq_i = eq_i.all() 

260 if not eq_i: 

261 all_equal = False 

262 break 

263 if all_equal: 

264 data_vec = [data_vec[0]] # warnings identical across sweeps 

265 for i, data in enumerate(data_vec): 

266 if len(data) == 0: 

267 continue 

268 data = sorted(data, key=lambda l: l[0]) # sort by msg 

269 title = wtype 

270 if len(data_vec) > 1: 

271 title += " in sweep %i" % i 

272 if wtype == "Unexpectedly Tight Constraints" and data[0][1]: 

273 data = [(-int(1e5*relax_sensitivity), 

274 "%+6.2g" % relax_sensitivity, id(c), c) 

275 for _, (relax_sensitivity, c) in data] 

276 lines += constraint_table(data, title, **kwargs) 

277 elif wtype == "Unexpectedly Loose Constraints" and data[0][1]: 

278 data = [(-int(1e5*rel_diff), 

279 "%.4g %s %.4g" % tightvalues, id(c), c) 

280 for _, (rel_diff, tightvalues, c) in data] 

281 lines += constraint_table(data, title, **kwargs) 

282 else: 

283 lines += [title] + ["-"*len(wtype)] 

284 lines += [msg for msg, _ in data] + [""] 

285 if len(lines) == 3: # just the header 

286 return [] 

287 lines[-1] = "~~~~~~~~" 

288 return lines + [""] 

289 

290def bdtable_gen(key): 

291 "Generator for breakdown tablefns" 

292 

293 def bdtable(self, _showvars, **_): 

294 "Cost breakdown plot" 

295 bds = Breakdowns(self) 

296 original_stdout = sys.stdout 

297 try: 

298 sys.stdout = SolverLog(original_stdout, verbosity=0) 

299 bds.plot(key) 

300 finally: 

301 lines = sys.stdout.lines() 

302 sys.stdout = original_stdout 

303 return lines 

304 

305 return bdtable 

306 

307 

308TABLEFNS = {"sensitivities": senss_table, 

309 "top sensitivities": topsenss_table, 

310 "insensitivities": insenss_table, 

311 "model sensitivities": msenss_table, 

312 "tightest constraints": tight_table, 

313 "loose constraints": loose_table, 

314 "warnings": warnings_table, 

315 "model sensitivities breakdown": bdtable_gen("model sensitivities"), 

316 "cost breakdown": bdtable_gen("cost") 

317 } 

318 

319def unrolled_absmax(values): 

320 "From an iterable of numbers and arrays, returns the largest magnitude" 

321 finalval, absmaxest = None, 0 

322 for val in values: 

323 absmaxval = np.abs(val).max() 

324 if absmaxval >= absmaxest: 

325 absmaxest, finalval = absmaxval, val 

326 if getattr(finalval, "shape", None): 

327 return finalval[np.unravel_index(np.argmax(np.abs(finalval)), 

328 finalval.shape)] 

329 return finalval 

330 

331 

332def cast(function, val1, val2): 

333 "Relative difference between val1 and val2 (positive if val2 is larger)" 

334 with pywarnings.catch_warnings(): # skip those pesky divide-by-zeros 

335 pywarnings.simplefilter("ignore") 

336 if hasattr(val1, "shape") and hasattr(val2, "shape"): 

337 if val1.ndim == val2.ndim: 

338 return function(val1, val2) 

339 lessdim, dimmest = sorted([val1, val2], key=lambda v: v.ndim) 

340 dimdelta = dimmest.ndim - lessdim.ndim 

341 add_axes = (slice(None),)*lessdim.ndim + (np.newaxis,)*dimdelta 

342 if dimmest is val1: 

343 return function(dimmest, lessdim[add_axes]) 

344 if dimmest is val2: 

345 return function(lessdim[add_axes], dimmest) 

346 return function(val1, val2) 

347 

348 

349class SolutionArray(DictOfLists): 

350 """A dictionary (of dictionaries) of lists, with convenience methods. 

351 

352 Items 

353 ----- 

354 cost : array 

355 variables: dict of arrays 

356 sensitivities: dict containing: 

357 monomials : array 

358 posynomials : array 

359 variables: dict of arrays 

360 localmodels : NomialArray 

361 Local power-law fits (small sensitivities are cut off) 

362 

363 Example 

364 ------- 

365 >>> import gpkit 

366 >>> import numpy as np 

367 >>> x = gpkit.Variable("x") 

368 >>> x_min = gpkit.Variable("x_{min}", 2) 

369 >>> sol = gpkit.Model(x, [x >= x_min]).solve(verbosity=0) 

370 >>> 

371 >>> # VALUES 

372 >>> values = [sol(x), sol.subinto(x), sol["variables"]["x"]] 

373 >>> assert all(np.array(values) == 2) 

374 >>> 

375 >>> # SENSITIVITIES 

376 >>> senss = [sol.sens(x_min), sol.sens(x_min)] 

377 >>> senss.append(sol["sensitivities"]["variables"]["x_{min}"]) 

378 >>> assert all(np.array(senss) == 1) 

379 """ 

380 modelstr = "" 

381 _name_collision_varkeys = None 

382 _lineageset = False 

383 table_titles = {"choicevariables": "Choice Variables", 

384 "sweepvariables": "Swept Variables", 

385 "freevariables": "Free Variables", 

386 "constants": "Fixed Variables", # TODO: change everywhere 

387 "variables": "Variables"} 

388 

389 def set_necessarylineage(self, clear=False): # pylint: disable=too-many-branches 

390 "Returns the set of contained varkeys whose names are not unique" 

391 if self._name_collision_varkeys is None: 

392 self._name_collision_varkeys = {} 

393 self["variables"].update_keymap() 

394 keymap = self["variables"].keymap 

395 name_collisions = defaultdict(set) 

396 for key in keymap: 

397 if hasattr(key, "key"): 

398 if len(keymap[key.name]) == 1: # very unique 

399 self._name_collision_varkeys[key] = 0 

400 else: 

401 shortname = key.str_without(["lineage", "vec"]) 

402 if len(keymap[shortname]) > 1: 

403 name_collisions[shortname].add(key) 

404 for varkeys in name_collisions.values(): 

405 min_namespaced = defaultdict(set) 

406 for vk in varkeys: 

407 *_, mineage = vk.lineagestr().split(".") 

408 min_namespaced[(mineage, 1)].add(vk) 

409 while any(len(vks) > 1 for vks in min_namespaced.values()): 

410 for key, vks in list(min_namespaced.items()): 

411 if len(vks) <= 1: 

412 continue 

413 del min_namespaced[key] 

414 mineage, idx = key 

415 idx += 1 

416 for vk in vks: 

417 lineages = vk.lineagestr().split(".") 

418 submineage = lineages[-idx] + "." + mineage 

419 min_namespaced[(submineage, idx)].add(vk) 

420 for (_, idx), vks in min_namespaced.items(): 

421 vk, = vks 

422 self._name_collision_varkeys[vk] = idx 

423 if clear: 

424 self._lineageset = False 

425 for vk in self._name_collision_varkeys: 

426 del vk.descr["necessarylineage"] 

427 else: 

428 self._lineageset = True 

429 for vk, idx in self._name_collision_varkeys.items(): 

430 vk.descr["necessarylineage"] = idx 

431 

432 def __len__(self): 

433 try: 

434 return len(self["cost"]) 

435 except TypeError: 

436 return 1 

437 except KeyError: 

438 return 0 

439 

440 def __call__(self, posy): 

441 posy_subbed = self.subinto(posy) 

442 return getattr(posy_subbed, "c", posy_subbed) 

443 

444 def almost_equal(self, other, reltol=1e-3): 

445 "Checks for almost-equality between two solutions" 

446 svars, ovars = self["variables"], other["variables"] 

447 svks, ovks = set(svars), set(ovars) 

448 if svks != ovks: 

449 return False 

450 for key in svks: 

451 reldiff = np.max(abs(cast(np.divide, svars[key], ovars[key]) - 1)) 

452 if reldiff >= reltol: 

453 return False 

454 return True 

455 

456 # pylint: disable=too-many-locals, too-many-branches, too-many-statements 

457 def diff(self, other, showvars=None, *, 

458 constraintsdiff=True, senssdiff=False, sensstol=0.1, 

459 absdiff=False, abstol=0.1, reldiff=True, reltol=1.0, 

460 sortmodelsbysenss=True, **tableargs): 

461 """Outputs differences between this solution and another 

462 

463 Arguments 

464 --------- 

465 other : solution or string 

466 strings will be treated as paths to pickled solutions 

467 senssdiff : boolean 

468 if True, show sensitivity differences 

469 sensstol : float 

470 the smallest sensitivity difference worth showing 

471 absdiff : boolean 

472 if True, show absolute differences 

473 abstol : float 

474 the smallest absolute difference worth showing 

475 reldiff : boolean 

476 if True, show relative differences 

477 reltol : float 

478 the smallest relative difference worth showing 

479 

480 Returns 

481 ------- 

482 str 

483 """ 

484 if sortmodelsbysenss: 

485 tableargs["sortmodelsbysenss"] = self["sensitivities"]["models"] 

486 else: 

487 tableargs["sortmodelsbysenss"] = False 

488 tableargs.update({"hidebelowminval": True, "sortbyvals": True, 

489 "skipifempty": False}) 

490 if isinstance(other, Strings): 

491 if other[-4:] == ".pgz": 

492 other = SolutionArray.decompress_file(other) 

493 else: 

494 other = pickle.load(open(other, "rb")) 

495 svars, ovars = self["variables"], other["variables"] 

496 lines = ["Solution Diff", 

497 "=============", 

498 "(argument is the baseline solution)", ""] 

499 svks, ovks = set(svars), set(ovars) 

500 if showvars: 

501 lines[0] += " (for selected variables)" 

502 lines[1] += "=========================" 

503 showvars = self._parse_showvars(showvars) 

504 svks = {k for k in showvars if k in svars} 

505 ovks = {k for k in showvars if k in ovars} 

506 if constraintsdiff and other.modelstr and self.modelstr: 

507 if self.modelstr == other.modelstr: 

508 lines += ["** no constraint differences **", ""] 

509 else: 

510 cdiff = ["Constraint Differences", 

511 "**********************"] 

512 cdiff.extend(list(difflib.unified_diff( 

513 other.modelstr.split("\n"), self.modelstr.split("\n"), 

514 lineterm="", n=3))[2:]) 

515 cdiff += ["", "**********************", ""] 

516 lines += cdiff 

517 if svks - ovks: 

518 lines.append("Variable(s) of this solution" 

519 " which are not in the argument:") 

520 lines.append("\n".join(" %s" % key for key in svks - ovks)) 

521 lines.append("") 

522 if ovks - svks: 

523 lines.append("Variable(s) of the argument" 

524 " which are not in this solution:") 

525 lines.append("\n".join(" %s" % key for key in ovks - svks)) 

526 lines.append("") 

527 sharedvks = svks.intersection(ovks) 

528 if reldiff: 

529 rel_diff = {vk: 100*(cast(np.divide, svars[vk], ovars[vk]) - 1) 

530 for vk in sharedvks} 

531 lines += var_table(rel_diff, 

532 "Relative Differences |above %g%%|" % reltol, 

533 valfmt="%+.1f%% ", vecfmt="%+6.1f%% ", 

534 minval=reltol, printunits=False, **tableargs) 

535 if lines[-2][:10] == "-"*10: # nothing larger than reltol 

536 lines.insert(-1, ("The largest is %+g%%." 

537 % unrolled_absmax(rel_diff.values()))) 

538 if absdiff: 

539 abs_diff = {vk: cast(sub, svars[vk], ovars[vk]) for vk in sharedvks} 

540 lines += var_table(abs_diff, 

541 "Absolute Differences |above %g|" % abstol, 

542 valfmt="%+.2g", vecfmt="%+8.2g", 

543 minval=abstol, **tableargs) 

544 if lines[-2][:10] == "-"*10: # nothing larger than abstol 

545 lines.insert(-1, ("The largest is %+g." 

546 % unrolled_absmax(abs_diff.values()))) 

547 if senssdiff: 

548 ssenss = self["sensitivities"]["variables"] 

549 osenss = other["sensitivities"]["variables"] 

550 senss_delta = {vk: cast(sub, ssenss[vk], osenss[vk]) 

551 for vk in svks.intersection(ovks)} 

552 lines += var_table(senss_delta, 

553 "Sensitivity Differences |above %g|" % sensstol, 

554 valfmt="%+-.2f ", vecfmt="%+-6.2f", 

555 minval=sensstol, printunits=False, **tableargs) 

556 if lines[-2][:10] == "-"*10: # nothing larger than sensstol 

557 lines.insert(-1, ("The largest is %+g." 

558 % unrolled_absmax(senss_delta.values()))) 

559 return "\n".join(lines) 

560 

561 def save(self, filename="solution.pkl", 

562 *, saveconstraints=True, **pickleargs): 

563 """Pickles the solution and saves it to a file. 

564 

565 Solution can then be loaded with e.g.: 

566 >>> import pickle 

567 >>> pickle.load(open("solution.pkl")) 

568 """ 

569 with SolSavingEnvironment(self, saveconstraints): 

570 pickle.dump(self, open(filename, "wb"), **pickleargs) 

571 

572 def save_compressed(self, filename="solution.pgz", 

573 *, saveconstraints=True, **cpickleargs): 

574 "Pickle a file and then compress it into a file with extension." 

575 with gzip.open(filename, "wb") as f: 

576 with SolSavingEnvironment(self, saveconstraints): 

577 pickled = pickle.dumps(self, **cpickleargs) 

578 f.write(pickletools.optimize(pickled)) 

579 

580 @staticmethod 

581 def decompress_file(file): 

582 "Load a gzip-compressed pickle file" 

583 with gzip.open(file, "rb") as f: 

584 return pickle.Unpickler(f).load() 

585 

586 def varnames(self, showvars, exclude): 

587 "Returns list of variables, optionally with minimal unique names" 

588 if showvars: 

589 showvars = self._parse_showvars(showvars) 

590 self.set_necessarylineage() 

591 names = {} 

592 for key in showvars or self["variables"]: 

593 for k in self["variables"].keymap[key]: 

594 names[k.str_without(exclude)] = k 

595 self.set_necessarylineage(clear=True) 

596 return names 

597 

598 def savemat(self, filename="solution.mat", *, showvars=None, 

599 excluded=("vec")): 

600 "Saves primal solution as matlab file" 

601 from scipy.io import savemat 

602 savemat(filename, 

603 {name.replace(".", "_"): np.array(self["variables"][key], "f") 

604 for name, key in self.varnames(showvars, excluded).items()}) 

605 

606 def todataframe(self, showvars=None, excluded=("vec")): 

607 "Returns primal solution as pandas dataframe" 

608 import pandas as pd # pylint:disable=import-error 

609 rows = [] 

610 cols = ["Name", "Index", "Value", "Units", "Label", 

611 "Lineage", "Other"] 

612 for _, key in sorted(self.varnames(showvars, excluded).items(), 

613 key=lambda k: k[0]): 

614 value = self["variables"][key] 

615 if key.shape: 

616 idxs = [] 

617 it = np.nditer(np.empty(value.shape), flags=['multi_index']) 

618 while not it.finished: 

619 idx = it.multi_index 

620 idxs.append(idx[0] if len(idx) == 1 else idx) 

621 it.iternext() 

622 else: 

623 idxs = [None] 

624 for idx in idxs: 

625 row = [ 

626 key.name, 

627 "" if idx is None else idx, 

628 value if idx is None else value[idx]] 

629 rows.append(row) 

630 row.extend([ 

631 key.unitstr(), 

632 key.label or "", 

633 key.lineage or "", 

634 ", ".join("%s=%s" % (k, v) for (k, v) in key.descr.items() 

635 if k not in ["name", "units", "unitrepr", 

636 "idx", "shape", "veckey", 

637 "value", "vecfn", 

638 "lineage", "label"])]) 

639 return pd.DataFrame(rows, columns=cols) 

640 

641 def savetxt(self, filename="solution.txt", *, printmodel=True, **kwargs): 

642 "Saves solution table as a text file" 

643 with open(filename, "w") as f: 

644 if printmodel: 

645 f.write(self.modelstr + "\n") 

646 f.write(self.table(**kwargs)) 

647 

648 def savejson(self, filename="solution.json", showvars=None): 

649 "Saves solution table as a json file" 

650 sol_dict = {} 

651 if self._lineageset: 

652 self.set_necessarylineage(clear=True) 

653 data = self["variables"] 

654 if showvars: 

655 showvars = self._parse_showvars(showvars) 

656 data = {k: data[k] for k in showvars if k in data} 

657 # add appropriate data for each variable to the dictionary 

658 for k, v in data.items(): 

659 key = str(k) 

660 if isinstance(v, np.ndarray): 

661 val = {"v": v.tolist(), "u": k.unitstr()} 

662 else: 

663 val = {"v": v, "u": k.unitstr()} 

664 sol_dict[key] = val 

665 with open(filename, "w") as f: 

666 json.dump(sol_dict, f) 

667 

668 def savecsv(self, filename="solution.csv", *, valcols=5, showvars=None):