Coverage for moptipy/examples/bitstrings/onemax.py: 94%

1"""

2An objective function counting the number of ones in a bit string.

4This function tries to maximize the number of `True` bits in a bit string.

5Therefore, it returns the lowest possible value 0 if all bits are `True`.

6This is the global optimum.

7It returns the highest possible value `n` if all bits are `False`. This is

8the worst possible value.

101. Heinz Mühlenbein. How Genetic Algorithms Really Work: Mutation and

11 Hillclimbing. In Reinhard Männer and Bernard Manderick, editors,

12 *Proceedings of Parallel Problem Solving from Nature 2 (PPSN-II),*

13 September 28-30, 1992, Brussels, Belgium, pages 15-26. Elsevier.

14 https://www.researchgate.net/publication/220702092

152. Stefan Droste, Thomas Jansen, and Ingo Wegener. Upper and Lower Bounds for

16 Randomized Search Heuristics in Black-Box Optimization. *Theory of

17 Computing Systems.* 39(4):525-544. July 2006.

18 doi: https://doi.org/10.1007/s00224-004-1177-z

193. Thomas Weise, Zhize Wu, Xinlu Li, and Yan Chen. Frequency Fitness

20 Assignment: Making Optimization Algorithms Invariant under Bijective

21 Transformations of the Objective Function Value. *IEEE Transactions on

22 Evolutionary Computation* 25(2):307-319. April 2021. Preprint available at

23 arXiv:2001.01416v5 [cs.NE] 15 Oct 2020.

24 https://dx.doi.org/10.1109/TEVC.2020.3032090

254. v

26"""

28from typing import Callable, Iterator, cast

30import numba # type: ignore

31import numpy as np

33from moptipy.examples.bitstrings.bitstring_problem import BitStringProblem

36@numba.njit(nogil=True, cache=True)

37def onemax(x: np.ndarray) -> int:

38 """

39 Get the length of a string minus the number of ones in it.

41 :param x: the np array

42 :return: the length of the string minus the number of ones, i.e., the

43 number of zeros

45 >>> onemax(np.array([True, True, False, False, False]))

46 3

47 >>> onemax(np.array([True, False, True, False, False]))

48 3

49 >>> onemax(np.array([False, True, True, False, False]))

50 3

51 >>> onemax(np.array([True, True, True, True, True]))

52 0

53 >>> onemax(np.array([False, True, True, True, True]))

54 1

55 >>> onemax(np.array([False, False, False, False, False]))

56 5

58 # n = 1 and 0 true bits

59 >>> onemax(np.array([0]))

60 1

62 # n = 1 and 1 true bit

63 >>> onemax(np.array([1]))

64 0

66 # n = 2 and 0 true bits

67 >>> onemax(np.array([0, 0]))

68 2

70 # n = 2 and 1 true bit

71 >>> onemax(np.array([0, 1]))

72 1

74 # n = 2 and 1 true bit

75 >>> onemax(np.array([1, 0]))

76 1

78 # n = 2 and 1 true bit

79 >>> onemax(np.array([0, 1]))

80 1

82 # n = 2 and 2 true bits

83 >>> onemax(np.array([1, 1]))

84 0

86 # n = 3 and 0 true bits

87 >>> onemax(np.array([0, 0, 0]))

88 3

90 # n = 3 and 1 true bit

91 >>> onemax(np.array([1, 0, 0]))

92 2

94 # n = 3 and 1 true bit

95 >>> onemax(np.array([0, 1, 0]))

96 2

98 # n = 3 and 1 true bit

99 >>> onemax(np.array([0, 0, 1]))

100 2

101

102 # n = 3 and 2 true bits

103 >>> onemax(np.array([1, 1, 0]))

104 1

105

106 # n = 3 and 2 true bits

107 >>> onemax(np.array([0, 1, 1]))

108 1

109

110 # n = 3 and 2 true bits

111 >>> onemax(np.array([1, 1, 0]))

112 1

113

114 # n = 3 and 3 true bits

115 >>> onemax(np.array([1, 1, 1]))

116 0

117

118 # n = 4 and 0 true bits

119 >>> onemax(np.array([0, 0, 0, 0]))

120 4

121

122 # n = 4 and 1 true bit

123 >>> onemax(np.array([1, 0, 0, 0]))

124 3

125

126 # n = 4 and 1 true bit

127 >>> onemax(np.array([0, 0, 0, 1]))

128 3

129

130 # n = 4 and 1 true bit

131 >>> onemax(np.array([0, 0, 1, 0]))

132 3

133

134 # n = 4 and 2 true bits

135 >>> onemax(np.array([0, 0, 1, 1]))

136 2

137

138 # n = 4 and 2 true bits

139 >>> onemax(np.array([0, 1, 0, 1]))

140 2

141

142 # n = 4 and 2 true bits

143 >>> onemax(np.array([0, 1, 0, 1]))

144 2

145

146 # n = 4 and 3 true bits

147 >>> onemax(np.array([0, 1, 1, 1]))

148 1

149

150 # n = 4 and 3 true bits

151 >>> onemax(np.array([1, 1, 1, 0]))

152 1

153

154 # n = 4 and 3 true bits

155 >>> onemax(np.array([1, 0, 1, 1]))

156 1

157

158 # n = 4 and 4 true bits

159 >>> onemax(np.array([1, 1, 1, 1]))

160 0

161

162 # n = 5 and 0 true bits

163 >>> onemax(np.array([0, 0, 0, 0, 0]))

164 5

165

166 # n = 5 and 1 true bit

167 >>> onemax(np.array([0, 0, 0, 0, 1]))

168 4

169

170 # n = 5 and 1 true bit

171 >>> onemax(np.array([0, 1, 0, 0, 0]))

172 4

173

174 # n = 5 and 1 true bit

175 >>> onemax(np.array([1, 0, 0, 0, 0]))

176 4

177

178 # n = 5 and 2 true bits

179 >>> onemax(np.array([0, 1, 0, 0, 1]))

180 3

181

182 # n = 5 and 2 true bits

183 >>> onemax(np.array([0, 1, 1, 0, 0]))

184 3

185

186 # n = 5 and 2 true bits

187 >>> onemax(np.array([0, 0, 0, 1, 1]))

188 3

189

190 # n = 5 and 3 true bits

191 >>> onemax(np.array([1, 0, 1, 1, 0]))

192 2

193

194 # n = 5 and 3 true bits

195 >>> onemax(np.array([1, 1, 0, 1, 0]))

196 2

197

198 # n = 5 and 3 true bits

199 >>> onemax(np.array([0, 1, 1, 1, 0]))

200 2

201

202 # n = 5 and 4 true bits

203 >>> onemax(np.array([1, 0, 1, 1, 1]))

204 1

205

206 # n = 5 and 4 true bits

207 >>> onemax(np.array([1, 1, 0, 1, 1]))

208 1

209

210 # n = 5 and 4 true bits

211 >>> onemax(np.array([1, 0, 1, 1, 1]))

212 1

213

214 # n = 5 and 5 true bits

215 >>> onemax(np.array([1, 1, 1, 1, 1]))

216 0

217

218 # n = 6 and 0 true bits

219 >>> onemax(np.array([0, 0, 0, 0, 0, 0]))

220 6

221

222 # n = 6 and 1 true bit

223 >>> onemax(np.array([0, 0, 0, 0, 1, 0]))

224 5

225

226 # n = 6 and 1 true bit

227 >>> onemax(np.array([1, 0, 0, 0, 0, 0]))

228 5

229

230 # n = 6 and 1 true bit

231 >>> onemax(np.array([0, 0, 0, 0, 1, 0]))

232 5

233

234 # n = 6 and 2 true bits

235 >>> onemax(np.array([0, 1, 0, 1, 0, 0]))

236 4

237

238 # n = 6 and 2 true bits

239 >>> onemax(np.array([0, 1, 0, 0, 1, 0]))

240 4

241

242 # n = 6 and 2 true bits

243 >>> onemax(np.array([0, 0, 0, 0, 1, 1]))

244 4

245

246 # n = 6 and 3 true bits

247 >>> onemax(np.array([0, 0, 1, 0, 1, 1]))

248 3

249

250 # n = 6 and 3 true bits

251 >>> onemax(np.array([1, 0, 0, 1, 0, 1]))

252 3

253

254 # n = 6 and 3 true bits

255 >>> onemax(np.array([0, 1, 1, 0, 0, 1]))

256 3

257

258 # n = 6 and 4 true bits

259 >>> onemax(np.array([1, 1, 1, 0, 1, 0]))

260 2

261

262 # n = 6 and 4 true bits

263 >>> onemax(np.array([1, 1, 0, 0, 1, 1]))

264 2

265

266 # n = 6 and 4 true bits

267 >>> onemax(np.array([1, 1, 1, 0, 1, 0]))

268 2

269

270 # n = 6 and 5 true bits

271 >>> onemax(np.array([1, 1, 0, 1, 1, 1]))

272 1

273

274 # n = 6 and 5 true bits

275 >>> onemax(np.array([1, 1, 1, 1, 0, 1]))

276 1

277

278 # n = 6 and 5 true bits

279 >>> onemax(np.array([1, 1, 1, 1, 0, 1]))

280 1

281

282 # n = 6 and 6 true bits

283 >>> onemax(np.array([1, 1, 1, 1, 1, 1]))

284 0

285

286 # n = 7 and 0 true bits

287 >>> onemax(np.array([0, 0, 0, 0, 0, 0, 0]))

288 7

289

290 # n = 7 and 1 true bit

291 >>> onemax(np.array([0, 1, 0, 0, 0, 0, 0]))

292 6

293

294 # n = 7 and 1 true bit

295 >>> onemax(np.array([0, 0, 0, 0, 1, 0, 0]))

296 6

297

298 # n = 7 and 1 true bit

299 >>> onemax(np.array([0, 1, 0, 0, 0, 0, 0]))

300 6

301

302 # n = 7 and 2 true bits

303 >>> onemax(np.array([1, 0, 0, 0, 1, 0, 0]))

304 5

305

306 # n = 7 and 2 true bits

307 >>> onemax(np.array([0, 1, 0, 1, 0, 0, 0]))

308 5

309

310 # n = 7 and 2 true bits

311 >>> onemax(np.array([1, 0, 0, 0, 0, 0, 1]))

312 5

313

314 # n = 7 and 3 true bits

315 >>> onemax(np.array([1, 0, 1, 1, 0, 0, 0]))

316 4

317

318 # n = 7 and 3 true bits

319 >>> onemax(np.array([0, 0, 1, 1, 0, 0, 1]))

320 4

321

322 # n = 7 and 3 true bits

323 >>> onemax(np.array([0, 0, 1, 1, 0, 0, 1]))

324 4

325

326 # n = 7 and 4 true bits

327 >>> onemax(np.array([0, 1, 0, 1, 1, 1, 0]))

328 3

329

330 # n = 7 and 4 true bits

331 >>> onemax(np.array([1, 1, 1, 0, 1, 0, 0]))

332 3

333

334 # n = 7 and 4 true bits

335 >>> onemax(np.array([0, 1, 1, 1, 0, 1, 0]))

336 3

337

338 # n = 7 and 5 true bits

339 >>> onemax(np.array([1, 1, 1, 1, 1, 0, 0]))

340 2

341

342 # n = 7 and 5 true bits

343 >>> onemax(np.array([1, 1, 1, 1, 0, 1, 0]))

344 2

345

346 # n = 7 and 5 true bits

347 >>> onemax(np.array([0, 1, 1, 1, 1, 1, 0]))

348 2

349

350 # n = 7 and 6 true bits

351 >>> onemax(np.array([1, 1, 1, 1, 0, 1, 1]))

352 1

353

354 # n = 7 and 6 true bits

355 >>> onemax(np.array([1, 1, 1, 0, 1, 1, 1]))

356 1

357

358 # n = 7 and 6 true bits

359 >>> onemax(np.array([0, 1, 1, 1, 1, 1, 1]))

360 1

361

362 # n = 7 and 7 true bits

363 >>> onemax(np.array([1, 1, 1, 1, 1, 1, 1]))

364 0

365

366 # n = 8 and 0 true bits

367 >>> onemax(np.array([0, 0, 0, 0, 0, 0, 0, 0]))

368 8

369

370 # n = 8 and 1 true bit

371 >>> onemax(np.array([0, 0, 0, 0, 0, 1, 0, 0]))

372 7

373

374 # n = 8 and 1 true bit

375 >>> onemax(np.array([1, 0, 0, 0, 0, 0, 0, 0]))

376 7

377

378 # n = 8 and 1 true bit

379 >>> onemax(np.array([0, 0, 0, 0, 0, 0, 0, 1]))

380 7

381

382 # n = 8 and 2 true bits

383 >>> onemax(np.array([0, 0, 0, 0, 0, 0, 1, 1]))

384 6

385

386 # n = 8 and 2 true bits

387 >>> onemax(np.array([0, 0, 1, 0, 0, 1, 0, 0]))

388 6

389

390 # n = 8 and 2 true bits

391 >>> onemax(np.array([0, 0, 0, 0, 0, 1, 1, 0]))

392 6

393

394 # n = 8 and 3 true bits

395 >>> onemax(np.array([0, 1, 0, 0, 1, 1, 0, 0]))

396 5

397

398 # n = 8 and 3 true bits

399 >>> onemax(np.array([0, 1, 0, 1, 1, 0, 0, 0]))

400 5

401

402 # n = 8 and 3 true bits

403 >>> onemax(np.array([0, 0, 0, 0, 1, 1, 1, 0]))

404 5

405

406 # n = 8 and 4 true bits

407 >>> onemax(np.array([1, 0, 1, 1, 0, 0, 1, 0]))

408 4

409

410 # n = 8 and 4 true bits

411 >>> onemax(np.array([1, 1, 0, 0, 1, 1, 0, 0]))

412 4

413

414 # n = 8 and 4 true bits

415 >>> onemax(np.array([1, 0, 0, 0, 1, 1, 0, 1]))

416 4

417

418 # n = 8 and 5 true bits

419 >>> onemax(np.array([0, 1, 1, 0, 0, 1, 1, 1]))

420 3

421

422 # n = 8 and 5 true bits

423 >>> onemax(np.array([1, 1, 0, 0, 1, 0, 1, 1]))

424 3

425

426 # n = 8 and 5 true bits

427 >>> onemax(np.array([1, 1, 0, 0, 1, 1, 0, 1]))

428 3

429

430 # n = 8 and 6 true bits

431 >>> onemax(np.array([1, 1, 0, 1, 1, 1, 1, 0]))

432 2

433

434 # n = 8 and 6 true bits

435 >>> onemax(np.array([1, 1, 0, 1, 1, 0, 1, 1]))

436 2

437

438 # n = 8 and 6 true bits

439 >>> onemax(np.array([0, 0, 1, 1, 1, 1, 1, 1]))

440 2

441

442 # n = 8 and 7 true bits

443 >>> onemax(np.array([1, 1, 1, 1, 1, 1, 0, 1]))

444 1

445

446 # n = 8 and 7 true bits

447 >>> onemax(np.array([1, 1, 1, 1, 1, 1, 1, 0]))

448 1

449

450 # n = 8 and 7 true bits

451 >>> onemax(np.array([1, 1, 1, 1, 1, 0, 1, 1]))

452 1

453

454 # n = 8 and 8 true bits

455 >>> onemax(np.array([1, 1, 1, 1, 1, 1, 1, 1]))

456 0

457

458 # n = 9 and 0 true bits

459 >>> onemax(np.array([0, 0, 0, 0, 0, 0, 0, 0, 0]))

460 9

461

462 # n = 9 and 1 true bit

463 >>> onemax(np.array([0, 0, 0, 0, 0, 0, 0, 1, 0]))

464 8

465

466 # n = 9 and 1 true bit

467 >>> onemax(np.array([0, 0, 0, 0, 0, 0, 0, 0, 1]))

468 8

469

470 # n = 9 and 1 true bit

471 >>> onemax(np.array([0, 0, 0, 0, 1, 0, 0, 0, 0]))

472 8

473

474 # n = 9 and 2 true bits

475 >>> onemax(np.array([1, 0, 0, 0, 0, 0, 0, 1, 0]))

476 7

477

478 # n = 9 and 2 true bits

479 >>> onemax(np.array([0, 1, 0, 0, 0, 0, 1, 0, 0]))

480 7

481

482 # n = 9 and 2 true bits

483 >>> onemax(np.array([0, 0, 1, 0, 1, 0, 0, 0, 0]))

484 7

485

486 # n = 9 and 3 true bits

487 >>> onemax(np.array([0, 0, 1, 0, 0, 1, 0, 0, 1]))

488 6

489

490 # n = 9 and 3 true bits

491 >>> onemax(np.array([1, 0, 0, 0, 0, 0, 0, 1, 1]))

492 6

493

494 # n = 9 and 3 true bits

495 >>> onemax(np.array([0, 0, 1, 0, 1, 0, 0, 1, 0]))

496 6

497

498 # n = 9 and 4 true bits

499 >>> onemax(np.array([0, 0, 0, 0, 1, 1, 0, 1, 1]))

500 5

501

502 # n = 9 and 4 true bits

503 >>> onemax(np.array([0, 0, 0, 1, 0, 0, 1, 1, 1]))

504 5

505

506 # n = 9 and 4 true bits

507 >>> onemax(np.array([0, 0, 1, 1, 1, 0, 0, 0, 1]))

508 5

509

510 # n = 9 and 5 true bits

511 >>> onemax(np.array([0, 0, 1, 1, 0, 1, 0, 1, 1]))

512 4

513

514 # n = 9 and 5 true bits

515 >>> onemax(np.array([0, 0, 1, 1, 0, 1, 0, 1, 1]))

516 4

517

518 # n = 9 and 5 true bits

519 >>> onemax(np.array([1, 1, 0, 0, 1, 0, 0, 1, 1]))

520 4

521

522 # n = 9 and 6 true bits

523 >>> onemax(np.array([0, 0, 1, 1, 1, 1, 1, 0, 1]))

524 3

525

526 # n = 9 and 6 true bits

527 >>> onemax(np.array([1, 1, 0, 0, 1, 0, 1, 1, 1]))

528 3

529

530 # n = 9 and 6 true bits

531 >>> onemax(np.array([0, 1, 1, 1, 0, 1, 1, 0, 1]))

532 3

533

534 # n = 9 and 7 true bits

535 >>> onemax(np.array([0, 1, 1, 0, 1, 1, 1, 1, 1]))

536 2

537

538 # n = 9 and 7 true bits

539 >>> onemax(np.array([1, 1, 0, 1, 1, 1, 1, 0, 1]))

540 2

541

542 # n = 9 and 7 true bits

543 >>> onemax(np.array([1, 1, 1, 0, 1, 1, 0, 1, 1]))

544 2

545

546 # n = 9 and 8 true bits

547 >>> onemax(np.array([1, 1, 1, 0, 1, 1, 1, 1, 1]))

548 1

549

550 # n = 9 and 8 true bits

551 >>> onemax(np.array([1, 1, 1, 1, 1, 0, 1, 1, 1]))

552 1

553

554 # n = 9 and 8 true bits

555 >>> onemax(np.array([1, 1, 1, 0, 1, 1, 1, 1, 1]))

556 1

557

558 # n = 9 and 9 true bits

559 >>> onemax(np.array([1, 1, 1, 1, 1, 1, 1, 1, 1]))

560 0

561

562 # n = 10 and 0 true bits

563 >>> onemax(np.array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))

564 10

565

566 # n = 10 and 1 true bit

567 >>> onemax(np.array([0, 0, 0, 1, 0, 0, 0, 0, 0, 0]))

568 9

569

570 # n = 10 and 1 true bit

571 >>> onemax(np.array([0, 0, 0, 0, 0, 0, 0, 0, 0, 1]))

572 9

573

574 # n = 10 and 1 true bit

575 >>> onemax(np.array([0, 0, 0, 0, 0, 0, 0, 0, 0, 1]))

576 9

577

578 # n = 10 and 2 true bits

579 >>> onemax(np.array([0, 1, 0, 0, 0, 0, 0, 1, 0, 0]))

580 8

581

582 # n = 10 and 2 true bits

583 >>> onemax(np.array([1, 1, 0, 0, 0, 0, 0, 0, 0, 0]))

584 8

585

586 # n = 10 and 2 true bits

587 >>> onemax(np.array([1, 0, 0, 1, 0, 0, 0, 0, 0, 0]))

588 8

589

590 # n = 10 and 3 true bits

591 >>> onemax(np.array([0, 0, 0, 1, 0, 0, 1, 1, 0, 0]))

592 7

593

594 # n = 10 and 3 true bits

595 >>> onemax(np.array([1, 0, 0, 0, 0, 0, 1, 0, 1, 0]))

596 7

597

598 # n = 10 and 3 true bits

599 >>> onemax(np.array([0, 1, 0, 0, 0, 0, 1, 1, 0, 0]))

600 7

601

602 # n = 10 and 4 true bits

603 >>> onemax(np.array([0, 0, 1, 1, 1, 0, 0, 1, 0, 0]))

604 6

605

606 # n = 10 and 4 true bits

607 >>> onemax(np.array([0, 1, 1, 0, 0, 1, 0, 0, 0, 1]))

608 6

609

610 # n = 10 and 4 true bits

611 >>> onemax(np.array([0, 0, 1, 1, 0, 1, 0, 0, 1, 0]))

612 6

613

614 # n = 10 and 5 true bits

615 >>> onemax(np.array([1, 1, 1, 0, 0, 1, 0, 1, 0, 0]))

616 5

617

618 # n = 10 and 5 true bits

619 >>> onemax(np.array([0, 1, 1, 0, 1, 1, 0, 0, 0, 1]))

620 5

621

622 # n = 10 and 5 true bits

623 >>> onemax(np.array([0, 1, 0, 1, 0, 1, 0, 1, 0, 1]))

624 5

625

626 # n = 10 and 6 true bits

627 >>> onemax(np.array([1, 1, 1, 0, 1, 0, 1, 1, 0, 0]))

628 4

629

630 # n = 10 and 6 true bits

631 >>> onemax(np.array([1, 1, 1, 1, 1, 0, 1, 0, 0, 0]))

632 4

633

634 # n = 10 and 6 true bits

635 >>> onemax(np.array([0, 0, 1, 1, 1, 1, 0, 1, 0, 1]))

636 4

637

638 # n = 10 and 7 true bits

639 >>> onemax(np.array([1, 1, 1, 1, 0, 0, 1, 1, 0, 1]))

640 3

641

642 # n = 10 and 7 true bits

643 >>> onemax(np.array([1, 1, 0, 1, 1, 1, 0, 1, 1, 0]))

644 3

645

646 # n = 10 and 7 true bits

647 >>> onemax(np.array([0, 0, 1, 1, 1, 1, 0, 1, 1, 1]))

648 3

649

650 # n = 10 and 8 true bits

651 >>> onemax(np.array([0, 1, 1, 1, 0, 1, 1, 1, 1, 1]))

652 2

653

654 # n = 10 and 8 true bits

655 >>> onemax(np.array([1, 1, 1, 1, 1, 0, 1, 1, 1, 0]))

656 2

657

658 # n = 10 and 8 true bits

659 >>> onemax(np.array([1, 1, 1, 1, 0, 1, 0, 1, 1, 1]))

660 2

661

662 # n = 10 and 9 true bits

663 >>> onemax(np.array([1, 1, 1, 1, 1, 1, 1, 1, 0, 1]))

664 1

665

666 # n = 10 and 9 true bits

667 >>> onemax(np.array([0, 1, 1, 1, 1, 1, 1, 1, 1, 1]))

668 1

669

670 # n = 10 and 9 true bits

671 >>> onemax(np.array([1, 1, 1, 1, 1, 1, 0, 1, 1, 1]))

672 1

673

674 # n = 10 and 10 true bits

675 >>> onemax(np.array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1]))

676 0

677 """

678 return len(x) - int(x.sum())

679

680

681class OneMax(BitStringProblem):

682 """Maximize the number of ones in a bit string."""

683

684 def __init__(self, n: int) -> None:

685 """

686 Initialize the onemax objective function.

687

688 :param n: the dimension of the problem

689

690 >>> print(OneMax(2).n)

691 2

692 >>> print(OneMax(4).evaluate(np.array([True, True, False, True])))

693 1

694 """

695 super().__init__(n)

696 self.evaluate = onemax # type: ignore

697

698 def __str__(self) -> str:

699 """

700 Get the name of the onemax objective function.

701

702 :return: `onemax_` + length of string

703

704 >>> OneMax(13)

705 onemax_13

706 """

707 return f"onemax_{self.n}"

708

709 @classmethod

710 def default_instances(

711 cls: type, scale_min: int = 2, scale_max: int = 8192) \

712 -> Iterator[Callable[[], "OneMax"]]:

713 """

714 Get the 202 default instances of the :class:`OneMax` problem.

715

716 :param scale_min: the minimum permitted scale, by default `2`

717 :param scale_max: the maximum permitted scale, by default `8192`

718 :returns: a sequence of default :class:`OneMax` instances

719

720 >>> len(list(OneMax.default_instances()))

721 202

722

723 >>> [x() for x in OneMax.default_instances()]

724 [onemax_2, onemax_3, onemax_4, onemax_5, onemax_6, onemax_7, \

725onemax_8, onemax_9, onemax_10, onemax_11, onemax_12, onemax_13, onemax_14, \

726onemax_15, onemax_16, onemax_17, onemax_18, onemax_19, onemax_20, onemax_21, \

727onemax_22, onemax_23, onemax_24, onemax_25, onemax_26, onemax_27, onemax_28, \

728onemax_29, onemax_30, onemax_31, onemax_32, onemax_33, onemax_36, onemax_40, \

729onemax_41, onemax_42, onemax_44, onemax_48, onemax_49, onemax_50, onemax_55, \

730onemax_59, onemax_60, onemax_64, onemax_66, onemax_70, onemax_77, onemax_79, \

731onemax_80, onemax_81, onemax_85, onemax_88, onemax_90, onemax_96, onemax_99, \

732onemax_100, onemax_107, onemax_111, onemax_121, onemax_125, onemax_128, \

733onemax_144, onemax_149, onemax_169, onemax_170, onemax_192, onemax_196, \

734onemax_199, onemax_200, onemax_222, onemax_225, onemax_243, onemax_256, \

735onemax_269, onemax_289, onemax_300, onemax_324, onemax_333, onemax_341, \

736onemax_343, onemax_359, onemax_361, onemax_384, onemax_400, onemax_441, \

737onemax_444, onemax_479, onemax_484, onemax_500, onemax_512, onemax_529, \

738onemax_555, onemax_576, onemax_600, onemax_625, onemax_641, onemax_666, \

739onemax_676, onemax_682, onemax_700, onemax_729, onemax_768, onemax_777, \

740onemax_784, onemax_800, onemax_841, onemax_857, onemax_888, onemax_900, \

741onemax_961, onemax_999, onemax_1000, onemax_1024, onemax_1089, onemax_1111, \

742onemax_1151, onemax_1156, onemax_1225, onemax_1296, onemax_1365, \

743onemax_1369, onemax_1444, onemax_1521, onemax_1536, onemax_1543, \

744onemax_1600, onemax_1681, onemax_1764, onemax_1849, onemax_1936, \

745onemax_2000, onemax_2025, onemax_2048, onemax_2063, onemax_2116, \

746onemax_2187, onemax_2209, onemax_2222, onemax_2304, onemax_2401, \

747onemax_2500, onemax_2601, onemax_2704, onemax_2730, onemax_2753, \

748onemax_2809, onemax_2916, onemax_3000, onemax_3025, onemax_3072, \

749onemax_3125, onemax_3136, onemax_3249, onemax_3333, onemax_3364, \

750onemax_3481, onemax_3600, onemax_3671, onemax_3721, onemax_3844, \

751onemax_3969, onemax_4000, onemax_4096, onemax_4225, onemax_4356, \

752onemax_4444, onemax_4489, onemax_4624, onemax_4761, onemax_4900, \

753onemax_4903, onemax_5000, onemax_5041, onemax_5184, onemax_5329, \

754onemax_5461, onemax_5476, onemax_5555, onemax_5625, onemax_5776, \

755onemax_5929, onemax_6000, onemax_6084, onemax_6144, onemax_6241, \

756onemax_6400, onemax_6547, onemax_6561, onemax_6666, onemax_6724, \

757onemax_6889, onemax_7000, onemax_7056, onemax_7225, onemax_7396, \

758onemax_7569, onemax_7744, onemax_7777, onemax_7921, onemax_8000, \

759onemax_8100, onemax_8192]

760

761 """

762 return cast("Iterator[Callable[[], OneMax]]",

763 super().default_instances( # type: ignore

764 scale_min, scale_max))

Coverage for moptipy / examples / bitstrings / onemax.py: 94%

16 statements