src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
AccountService { public List<Account> list(long userId) { return accountRepository.findByUserId(userId); } @Autowired AccountService(AccountRepository accountRepository, UserRepository userRepository); List<Account> list(long userId); Account get(long id); Account create(long userId, String description, boolean onBudget); } | @Test public void shouldListAccounts() { User bob = UserTestUtils.createBob(); Account checkings = AccountTestUtils.createCheckingsAccount(bob); Account savings = AccountTestUtils.createSavingsAccount(bob); when(accountRepositoryMock.findByUserId(bob.getId())).thenReturn(asList(checkings, savings)); List<Account> accounts = testSubject.list(bob.getId()); assertThat(accounts).containsExactlyInAnyOrder(checkings, savings); } |
AccountService { public Account get(long id) { return accountRepository.findOne(Example.of(new Account().setId(id))).orElse(null); } @Autowired AccountService(AccountRepository accountRepository, UserRepository userRepository); List<Account> list(long userId); Account get(long id); Account create(long userId, String description, boolean onBudget); } | @Test public void shoudlGetAccount() { User bob = UserTestUtils.createBob(); Account checkings = AccountTestUtils.createCheckingsAccount(bob); when(accountRepositoryMock.findOne(isA(Example.class))).thenReturn(Optional.of(checkings)); Account accounts = testSubject.get(checkings.getId()); assertThat(accounts).isEqualTo(checkings); } |
AccountService { public Account create(long userId, String description, boolean onBudget) { User user = userRepository.getOne(userId); Account account = new Account(description, onBudget, user); return accountRepository.saveAndFlush(account); } @Autowired AccountService(AccountRepository accountRepository, UserRepository userRepository); List<Account> list(long userId); Account get(long id); Account create(long userId, String description, boolean onBudget); } | @Test public void shouldCreateAnAccount() { User bob = UserTestUtils.createBob(); when(userRepositoryMock.getOne(bob.getId())).thenReturn(bob); when(accountRepositoryMock.saveAndFlush(isA(Account.class))).thenAnswer(invocation -> invocation.getArgument(0)); Account account = testSubject.create(bob.getId(), "Cash", true); assertThat(account).isNotNull(); assertThat(account.getUser()).isNotNull(); assertThat(account.getUser().getId()).isEqualTo(bob.getId()); assertThat(account.getDescription()).isEqualTo("Cash"); assertThat(account.isOnBudget()).isTrue(); } |
AccountResourceValidator implements Validator { @Override public void validate(Object target, Errors errors) { ValidationUtils.rejectIfEmptyOrWhitespace(errors, "description", "description.empty"); ValidationUtils.rejectIfEmptyOrWhitespace(errors, "onBudget", "onBudget.empty"); } @Override boolean supports(Class<?> clazz); @Override void validate(Object target, Errors errors); } | @Test public void descriptionShouldNotBeEmpty() { final AccountResource resource = new AccountResource("", true); final BeanPropertyBindingResult errors = createBindingResult(resource); testSubject.validate(resource, errors); assertThat(errors.getFieldError("description").getCode()).isEqualTo("description.empty"); }
@Test public void onBudgetShouldNotBeEmpty() { final AccountResource resource = new AccountResource("Cash", null); final BeanPropertyBindingResult errors = createBindingResult(resource); testSubject.validate(resource, errors); assertThat(errors.getFieldError("onBudget").getCode()).isEqualTo("onBudget.empty"); } |
AccountController { @GetMapping("/{accountId}") public Resource<AccountResource> get(@PathVariable("userId") long userId, @PathVariable("accountId") long accountId) { Account account = accountService.get(accountId); final AccountResource accountResource = accountResourceAssembler.toResource(account); return new Resource<>(accountResource); } @Autowired AccountController(AccountService accountService, AccountResourceAssembler accountResourceAssembler); @GetMapping Resources<AccountResource> list(@PathVariable("userId") long userId); @GetMapping("/{accountId}") Resource<AccountResource> get(@PathVariable("userId") long userId, @PathVariable("accountId") long accountId); @PostMapping(consumes = MediaType.APPLICATION_JSON_VALUE) ResponseEntity<AccountResource> create(@PathVariable("userId") long userId, @RequestBody @Valid AccountResource accountResource); } | @Test public void shouldGetOneAccount() throws Exception { User bob = UserTestUtils.createBob(); Account savingsAccount = AccountTestUtils.createSavingsAccount(bob); when(accountServiceMock.get(savingsAccount.getId())).thenReturn(savingsAccount); final MockHttpServletRequestBuilder requestBuilder = get("/users/{userId}/accounts/{id}", bob.getId(), savingsAccount.getId()).accept(MediaType.APPLICATION_JSON); final MvcResult mvcResult = mockMvc.perform(requestBuilder).andReturn(); final MockHttpServletResponse response = mvcResult.getResponse(); assertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value()); final AccountResource userResource = JsonHelper.fromJson(response.getContentAsString(), AccountResource.class); assertThat(userResource.getDescription()).isEqualTo(savingsAccount.getDescription()); assertThat(userResource.getOnBudget()).isEqualTo(savingsAccount.isOnBudget()); } |
AccountController { @PostMapping(consumes = MediaType.APPLICATION_JSON_VALUE) public ResponseEntity<AccountResource> create(@PathVariable("userId") long userId, @RequestBody @Valid AccountResource accountResource) { Account account = accountService.create(userId, accountResource.getDescription(), accountResource.getOnBudget()); final AccountResource createdAccountResource = accountResourceAssembler.toResource(account); return new ResponseEntity<>(createdAccountResource, HttpStatus.OK); } @Autowired AccountController(AccountService accountService, AccountResourceAssembler accountResourceAssembler); @GetMapping Resources<AccountResource> list(@PathVariable("userId") long userId); @GetMapping("/{accountId}") Resource<AccountResource> get(@PathVariable("userId") long userId, @PathVariable("accountId") long accountId); @PostMapping(consumes = MediaType.APPLICATION_JSON_VALUE) ResponseEntity<AccountResource> create(@PathVariable("userId") long userId, @RequestBody @Valid AccountResource accountResource); } | @Test public void shouldCreateAccount() throws Exception { String description = "Cash"; boolean onBudget = true; long userId = 42L; AccountResource accountResource = new AccountResource(description, onBudget); when(accountServiceMock.create(anyLong(), anyString(), anyBoolean())).thenAnswer(invocation -> new Account(invocation.getArgument(1), invocation.getArgument(2), new User().setId(invocation.getArgument(0))).setId(1L)); final MockHttpServletRequestBuilder requestBuilder = post("/users/{userId}/accounts", userId).accept(MediaType.APPLICATION_JSON) .content(JsonHelper.toJson(accountResource)).contentType(MediaType.APPLICATION_JSON); final MvcResult mvcResult = mockMvc.perform(requestBuilder).andReturn(); final MockHttpServletResponse response = mvcResult.getResponse(); assertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value()); AccountResource result = JsonHelper.fromJson(response.getContentAsString(), AccountResource.class); assertThat(result.getDescription()).isEqualTo(description); assertThat(result.getOnBudget()).isEqualTo(onBudget); verify(accountServiceMock).create(userId, description, onBudget); } |
AccountResourceAssembler extends ResourceAssemblerSupport<Account, AccountResource> { @Override public AccountResource toResource(Account entity) { final AccountResource accountResource = new AccountResource(entity.getDescription(), entity.isOnBudget()); accountResource.add(linkTo(methodOn(AccountController.class).get(entity.getUser().getId(), entity.getId())).withSelfRel()); accountResource.add(linkTo(methodOn(UserController.class).get(entity.getUser().getId())).withRel("user")); return accountResource; } AccountResourceAssembler(); @Override AccountResource toResource(Account entity); } | @Test public void shouldCreateResource() { Account entity = AccountTestUtils.createCheckingsAccount(UserTestUtils.createBob()); AccountResource resource = testSubject.toResource(entity); assertThat(resource.getDescription()).isEqualTo(entity.getDescription()); assertThat(resource.getOnBudget()).isEqualTo(entity.isOnBudget()); } |
CategorySpecifications { public Specification<Category> byUser(User user) { return (root, query, criteriaBuilder) -> criteriaBuilder.equal(root.get(Category_.masterCategory).get(MasterCategory_.user), user); } Specification<Category> byUser(User user); } | @Test public void byUser() { User user = userRepository.save(new User("Bob", "€")); MasterCategory mcMonthly = masterCategoryRepository.save(new MasterCategory().setName("Monthly").setUser(user)); MasterCategory mcSavings = masterCategoryRepository.save(new MasterCategory().setName("Savings").setUser(user)); categoryRepository.saveAll(asList( new Category().setName("Rent").setMasterCategory(mcMonthly), new Category().setName("Internet").setMasterCategory(mcMonthly), new Category().setName("Rainy Day Funds").setMasterCategory(mcSavings), new Category().setName("Christmas").setMasterCategory(mcSavings) )); Specification<Category> specification = testSubject.byUser(user); List<Category> categories = categoryRepository.findAll(specification); assertThat(categories).extracting("name").containsExactlyInAnyOrder("Rent", "Internet", "Rainy Day Funds", "Christmas"); } |
UserService { public List<User> list() { return userRepository.findAll(); } @Autowired UserService(UserRepository userRepository, UserManagementProperties userManagementProperties); List<User> list(); User create(String name, String currency); User get(long id); String getTestProperty(); } | @Test public void shouldReturnAllUser() throws Exception { final List<User> bobAndJane = UserTestUtils.createBobAndJane(); when(userRepositoryMock.findAll()).thenReturn(bobAndJane); final List<User> list = testSubject.list(); assertThat(list).isEqualTo(bobAndJane); } |
UserService { public User get(long id) { return userRepository.findOne(Example.of(new User().setId(id))).orElse(null); } @Autowired UserService(UserRepository userRepository, UserManagementProperties userManagementProperties); List<User> list(); User create(String name, String currency); User get(long id); String getTestProperty(); } | @Test public void shouldFindOneUser() { final User bob = UserTestUtils.createBob(); when(userRepositoryMock.findOne(isA(Example.class))).thenReturn(Optional.of(bob)); final User user = testSubject.get(bob.getId()); assertThat(user).isEqualToComparingFieldByField(bob); } |
UserService { public String getTestProperty() { return userManagementProperties.getTestProperty(); } @Autowired UserService(UserRepository userRepository, UserManagementProperties userManagementProperties); List<User> list(); User create(String name, String currency); User get(long id); String getTestProperty(); } | @Test public void shouldReadTestProperty() { assertThat(testSubject.getTestProperty()).isEqualTo("mockedTestProperty"); } |
UserResourceAssembler extends ResourceAssembler<User, UserResource> { @Override protected UserResource createResource(User user) { return new UserResource(user.getName(), user.getCurrency()); } @Autowired UserResourceAssembler(List<ResourceLinks<User>> resourceLinks); } | @Test public void createResource() throws Exception { UserResource userResource = testSubject.createResource(new User(NAME, CURRENCY)); assertThat(userResource.getName()).isEqualTo(NAME); assertThat(userResource.getCurrency()).isEqualTo(CURRENCY); } |
UserResourceValidator implements Validator { @Override public void validate(Object target, Errors errors) { ValidationUtils.rejectIfEmptyOrWhitespace(errors, "name", "name.empty"); ValidationUtils.rejectIfEmptyOrWhitespace(errors, "currency", "currency.empty"); } @Override boolean supports(Class<?> clazz); @Override void validate(Object target, Errors errors); } | @Test public void nameShouldNotBeEmpty() { final UserResource userResource = new UserResource("", "€"); final BeanPropertyBindingResult errors = createBindingResult(userResource); testSubject.validate(userResource, errors); assertThat(errors.getFieldError("name").getCode()).isEqualTo("name.empty"); }
@Test public void currencyShouldNotBeEmpty() { final UserResource userResource = new UserResource("Foo", ""); final BeanPropertyBindingResult errors = createBindingResult(userResource); testSubject.validate(userResource, errors); assertThat(errors.getFieldError("currency").getCode()).isEqualTo("currency.empty"); } |
UserControllerUserLinks extends ResourceLinks<User> { @Override public Collection<Link> generateLinks(User entity) { Link self = linkTo(methodOn(UserController.class).get(entity.getId())).withSelfRel(); Link users = linkTo(methodOn(UserController.class).list()).withRel("users"); return Arrays.asList(self, users); } UserControllerUserLinks(); @Override Collection<Link> generateLinks(User entity); } | @Test public void generateLinks() { List<Link> links = new ArrayList<>(testSubject.generateLinks(createUser())); assertThat(links.size()).isEqualTo(2); assertThat(links.get(0).getRel()).isEqualTo("self"); assertThat(links.get(0).getHref()).isEqualTo("/users/1"); assertThat(links.get(1).getRel()).isEqualTo("users"); assertThat(links.get(1).getHref()).isEqualTo("/users"); } |
UserController { @GetMapping("/{userId}") public Resource<UserResource> get(@PathVariable("userId") long userId) { User user = userService.get(userId); final UserResource userResource = userResourceAssembler.toResource(user); return new Resource<>(userResource); } @Autowired UserController(UserService userService, UserResourceAssembler userResourceAssembler); @GetMapping Resources<UserResource> list(); @GetMapping("/{userId}") Resource<UserResource> get(@PathVariable("userId") long userId); @PostMapping(consumes = MediaType.APPLICATION_JSON_VALUE) ResponseEntity<UserResource> create(@RequestBody @Valid UserResource userResource); } | @Test public void shouldGetOneUser() throws Exception { when(userServiceMock.get(anyLong())).thenReturn(UserTestUtils.createBob()); final MockHttpServletRequestBuilder requestBuilder = get("/users/{id}", 1L).accept(MediaType.APPLICATION_JSON); final MvcResult mvcResult = mockMvc.perform(requestBuilder).andReturn(); final MockHttpServletResponse response = mvcResult.getResponse(); assertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value()); final UserResource userResource = JsonHelper.fromJson(response.getContentAsString(), UserResource.class); assertThat(userResource.getName()).isEqualTo("Bob"); assertThat(userResource.getCurrency()).isEqualTo("€"); } |
UserController { @PostMapping(consumes = MediaType.APPLICATION_JSON_VALUE) public ResponseEntity<UserResource> create(@RequestBody @Valid UserResource userResource) { User user = userService.create(userResource.getName(), userResource.getCurrency()); final UserResource createdUserResource = userResourceAssembler.toResource(user); return new ResponseEntity<>(createdUserResource, HttpStatus.OK); } @Autowired UserController(UserService userService, UserResourceAssembler userResourceAssembler); @GetMapping Resources<UserResource> list(); @GetMapping("/{userId}") Resource<UserResource> get(@PathVariable("userId") long userId); @PostMapping(consumes = MediaType.APPLICATION_JSON_VALUE) ResponseEntity<UserResource> create(@RequestBody @Valid UserResource userResource); } | @Test public void shouldCreateUser() throws Exception { final String name = "Martha"; final String currency = "€"; final UserResource userResource = new UserResource(name, currency); when(userServiceMock.create(anyString(), anyString())).thenAnswer(invocation -> new User().setId(1L) .setName(invocation.getArgument(0)) .setCurrency(invocation.getArgument(1)) ); final MockHttpServletRequestBuilder requestBuilder = post("/users").accept(MediaType.APPLICATION_JSON) .content(JsonHelper.toJson(userResource)).contentType(MediaType.APPLICATION_JSON); final MvcResult mvcResult = mockMvc.perform(requestBuilder).andReturn(); final MockHttpServletResponse response = mvcResult.getResponse(); assertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value()); final UserResource result = JsonHelper.fromJson(response.getContentAsString(), UserResource.class); assertThat(result.getName()).isEqualTo(name); assertThat(result.getCurrency()).isEqualTo(currency); verify(userServiceMock).create(name, currency); } |
Order implements Serializable { @Override public String toString() { return "Order{" + "type=" + type + ", index=" + index + ", price=" + pricePerAsset + ", amount=" + amount + '}'; } protected Order(int index, BarSeries series, OrderType type); protected Order(int index, BarSeries series, OrderType type, Num amount); protected Order(int index, BarSeries series, OrderType type, Num amount, CostModel transactionCostModel); protected Order(int index, OrderType type, Num pricePerAsset); protected Order(int index, OrderType type, Num pricePerAsset, Num amount); protected Order(int index, OrderType type, Num pricePerAsset, Num amount, CostModel transactionCostModel); OrderType getType(); Num getCost(); int getIndex(); Num getPricePerAsset(); Num getNetPrice(); Num getAmount(); CostModel getCostModel(); boolean isBuy(); boolean isSell(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); static Order buyAt(int index, BarSeries series); static Order buyAt(int index, Num price, Num amount, CostModel transactionCostModel); static Order buyAt(int index, Num price, Num amount); static Order buyAt(int index, BarSeries series, Num amount); static Order buyAt(int index, BarSeries series, Num amount, CostModel transactionCostModel); static Order sellAt(int index, BarSeries series); static Order sellAt(int index, Num price, Num amount); static Order sellAt(int index, Num price, Num amount, CostModel transactionCostModel); static Order sellAt(int index, BarSeries series, Num amount); static Order sellAt(int index, BarSeries series, Num amount, CostModel transactionCostModel); Num getValue(); } | @Test public void overrideToString() { assertEquals(opEquals1.toString(), opEquals2.toString()); assertNotEquals(opEquals1.toString(), opNotEquals1.toString()); assertNotEquals(opEquals1.toString(), opNotEquals2.toString()); } |
NumberOfBarsCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isLessThan(criterionValue2); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); } | @Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(3), numOf(6))); assertFalse(criterion.betterThan(numOf(6), numOf(2))); } |
AverageProfitCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Num bars = numberOfBars.calculate(series, tradingRecord); if (bars.isEqual(series.numOf(0))) { return series.numOf(1); } return totalProfit.calculate(series, tradingRecord).pow(series.numOf(1).dividedBy(bars)); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); } | @Test public void calculateOnlyWithGainTrades() { series = new MockBarSeries(numFunction, 100d, 105d, 110d, 100d, 95d, 105d); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(2, series), Order.buyAt(3, series), Order.sellAt(5, series)); AnalysisCriterion averageProfit = getCriterion(); assertNumEquals(1.0243, averageProfit.calculate(series, tradingRecord)); }
@Test public void calculateWithASimpleTrade() { series = new MockBarSeries(numFunction, 100d, 105d, 110d, 100d, 95d, 105d); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(2, series)); AnalysisCriterion averageProfit = getCriterion(); assertNumEquals(numOf(110d / 100).pow(numOf(1d / 3)), averageProfit.calculate(series, tradingRecord)); }
@Test public void calculateOnlyWithLossTrades() { series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(1, series), Order.buyAt(2, series), Order.sellAt(5, series)); AnalysisCriterion averageProfit = getCriterion(); assertNumEquals(numOf(95d / 100 * 70d / 100).pow(numOf(1d / 6)), averageProfit.calculate(series, tradingRecord)); }
@Test public void calculateWithNoBarsShouldReturn1() { series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); AnalysisCriterion averageProfit = getCriterion(); assertNumEquals(1, averageProfit.calculate(series, new BaseTradingRecord())); }
@Test public void calculateWithOneTrade() { series = new MockBarSeries(numFunction, 100, 105); Trade trade = new Trade(Order.buyAt(0, series), Order.sellAt(1, series)); AnalysisCriterion average = getCriterion(); assertNumEquals(numOf(105d / 100).pow(numOf(0.5)), average.calculate(series, trade)); } |
AverageProfitCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); } | @Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(2.0), numOf(1.5))); assertFalse(criterion.betterThan(numOf(1.5), numOf(2.0))); } |
RewardRiskRatioCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return totalProfit.calculate(series, tradingRecord).dividedBy(maxDrawdown.calculate(series, tradingRecord)); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); @Override Num calculate(BarSeries series, Trade trade); } | @Test public void rewardRiskRatioCriterion() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 95, 100, 90, 95, 80, 120); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(1, series), Order.buyAt(2, series), Order.sellAt(4, series), Order.buyAt(5, series), Order.sellAt(7, series)); double totalProfit = (105d / 100) * (90d / 95d) * (120d / 95); double peak = (105d / 100) * (100d / 95); double low = (105d / 100) * (90d / 95) * (80d / 95); assertNumEquals(totalProfit / ((peak - low) / peak), rrc.calculate(series, tradingRecord)); }
@Test public void rewardRiskRatioCriterionOnlyWithGain() { MockBarSeries series = new MockBarSeries(numFunction, 1, 2, 3, 6, 8, 20, 3); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(1, series), Order.buyAt(2, series), Order.sellAt(5, series)); assertTrue(rrc.calculate(series, tradingRecord).isNaN()); }
@Test public void rewardRiskRatioCriterionWithNoTrades() { MockBarSeries series = new MockBarSeries(numFunction, 1, 2, 3, 6, 8, 20, 3); assertTrue(rrc.calculate(series, new BaseTradingRecord()).isNaN()); }
@Test public void withOneTrade() { MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 95, 100, 90, 95, 80, 120); Trade trade = new Trade(Order.buyAt(0, series), Order.sellAt(1, series)); AnalysisCriterion ratioCriterion = getCriterion(); assertNumEquals((95d / 100) / ((1d - 0.95d)), ratioCriterion.calculate(series, trade)); } |
CrossedDownIndicatorRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { final boolean satisfied = cross.getValue(index); traceIsSatisfied(index, satisfied); return satisfied; } CrossedDownIndicatorRule(Indicator<Num> indicator, Number threshold); CrossedDownIndicatorRule(Indicator<Num> indicator, Num threshold); CrossedDownIndicatorRule(Indicator<Num> first, Indicator<Num> second); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); } | @Test public void isSatisfied() { assertFalse(rule.isSatisfied(0)); assertFalse(rule.isSatisfied(1)); assertFalse(rule.isSatisfied(2)); assertTrue(rule.isSatisfied(3)); assertFalse(rule.isSatisfied(4)); assertTrue(rule.isSatisfied(5)); assertFalse(rule.isSatisfied(6)); assertFalse(rule.isSatisfied(7)); } |
RewardRiskRatioCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); @Override Num calculate(BarSeries series, Trade trade); } | @Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(3.5), numOf(2.2))); assertFalse(criterion.betterThan(numOf(1.5), numOf(2.7))); } |
ExpectedShortfallCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Returns returns = new Returns(series, tradingRecord, Returns.ReturnType.LOG); return calculateES(returns, confidence); } ExpectedShortfallCriterion(Double confidence); @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); } | @Test public void calculateOnlyWithGainTrades() { series = new MockBarSeries(numFunction, 100d, 105d, 106d, 107d, 108d, 115d); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(2, series), Order.buyAt(3, series), Order.sellAt(5, series)); AnalysisCriterion varCriterion = getCriterion(); assertNumEquals(numOf(0.0), varCriterion.calculate(series, tradingRecord)); }
@Test public void calculateWithASimpleTrade() { series = new MockBarSeries(numFunction, 100d, 104d, 90d, 100d, 95d, 105d); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(2, series)); AnalysisCriterion esCriterion = getCriterion(); assertNumEquals(numOf(Math.log(90d / 104)), esCriterion.calculate(series, tradingRecord)); }
@Test public void calculateOnlyWithLossTrade() { List<Double> prices = IntStream.rangeClosed(1, 100).asDoubleStream().boxed().sorted(Collections.reverseOrder()) .collect(Collectors.toList()); series = new MockBarSeries(numFunction, prices); Trade trade = new Trade(Order.buyAt(series.getBeginIndex(), series), Order.sellAt(series.getEndIndex(), series)); AnalysisCriterion esCriterion = getCriterion(); assertNumEquals(numOf(-0.35835189384561106), esCriterion.calculate(series, trade)); }
@Test public void calculateWithNoBarsShouldReturn0() { series = new MockBarSeries(numFunction, 100d, 95d, 100d, 80d, 85d, 70d); AnalysisCriterion varCriterion = getCriterion(); assertNumEquals(numOf(0), varCriterion.calculate(series, new BaseTradingRecord())); }
@Test public void calculateWithBuyAndHold() { series = new MockBarSeries(numFunction, 100d, 99d); Trade trade = new Trade(Order.buyAt(0, series), Order.sellAt(1, series)); AnalysisCriterion varCriterion = getCriterion(); assertNumEquals(numOf(Math.log(99d / 100)), varCriterion.calculate(series, trade)); } |
ExpectedShortfallCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } ExpectedShortfallCriterion(Double confidence); @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); } | @Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(-0.1), numOf(-0.2))); assertFalse(criterion.betterThan(numOf(-0.1), numOf(0.0))); } |
AverageProfitableTradesCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, Trade trade) { return isProfitableTrade(series, trade) ? series.numOf(1) : series.numOf(0); } @Override Num calculate(BarSeries series, Trade trade); @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); } | @Test public void calculate() { BarSeries series = new MockBarSeries(numFunction, 100d, 95d, 102d, 105d, 97d, 113d); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(1, series), Order.buyAt(2, series), Order.sellAt(3, series), Order.buyAt(4, series), Order.sellAt(5, series)); AnalysisCriterion average = getCriterion(); assertNumEquals(2d / 3, average.calculate(series, tradingRecord)); }
@Test public void calculateWithOneTrade() { BarSeries series = new MockBarSeries(numFunction, 100d, 95d, 102d, 105d, 97d, 113d); Trade trade = new Trade(Order.buyAt(0, series), Order.sellAt(1, series)); AnalysisCriterion average = getCriterion(); assertNumEquals(numOf(0), average.calculate(series, trade)); trade = new Trade(Order.buyAt(1, series), Order.sellAt(2, series)); assertNumEquals(1, average.calculate(series, trade)); } |
IsEqualRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { final boolean satisfied = first.getValue(index).isEqual(second.getValue(index)); traceIsSatisfied(index, satisfied); return satisfied; } IsEqualRule(Indicator<Num> indicator, Number value); IsEqualRule(Indicator<Num> indicator, Num value); IsEqualRule(Indicator<Num> first, Indicator<Num> second); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); } | @Test public void isSatisfied() { assertTrue(rule.isSatisfied(0)); assertFalse(rule.isSatisfied(1)); assertFalse(rule.isSatisfied(2)); assertFalse(rule.isSatisfied(3)); } |
AverageProfitableTradesCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } @Override Num calculate(BarSeries series, Trade trade); @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); } | @Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(12), numOf(8))); assertFalse(criterion.betterThan(numOf(8), numOf(12))); } |
NumberOfBreakEvenTradesCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { long numberOfLosingTrades = tradingRecord.getTrades().stream().filter(Trade::isClosed) .filter(trade -> isBreakEvenTrade(series, trade)).count(); return series.numOf(numberOfLosingTrades); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); } | @Test public void calculateWithNoTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); assertNumEquals(0, getCriterion().calculate(series, new BaseTradingRecord())); }
@Test public void calculateWithTwoTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(3, series), Order.buyAt(1, series), Order.sellAt(5, series)); assertNumEquals(2, getCriterion().calculate(series, tradingRecord)); }
@Test public void calculateWithOneTrade() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); Trade trade = new Trade(Order.buyAt(0, series), Order.sellAt(3, series)); assertNumEquals(1, getCriterion().calculate(series, trade)); } |
NumberOfBreakEvenTradesCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isLessThan(criterionValue2); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); } | @Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(3), numOf(6))); assertFalse(criterion.betterThan(numOf(7), numOf(4))); } |
ProfitLossPercentageCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return tradingRecord.getTrades().stream().filter(Trade::isClosed).map(trade -> calculate(series, trade)) .reduce(series.numOf(0), Num::plus); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); } | @Test public void calculateOnlyWithGainTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(2, series), Order.buyAt(3, series), Order.sellAt(5, series)); AnalysisCriterion profit = getCriterion(); assertNumEquals(10 + 5, profit.calculate(series, tradingRecord)); }
@Test public void calculateOnlyWithLossTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(1, series), Order.buyAt(2, series), Order.sellAt(5, series)); AnalysisCriterion profit = getCriterion(); assertNumEquals(-5 + -30, profit.calculate(series, tradingRecord)); }
@Test public void calculateWithOneWinningAndOneLosingTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 195, 100, 80, 85, 70); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(1, series), Order.buyAt(2, series), Order.sellAt(5, series)); AnalysisCriterion profit = getCriterion(); assertNumEquals(95 + -30, profit.calculate(series, tradingRecord)); } |
ProfitLossPercentageCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); } | @Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(50), numOf(45))); assertFalse(criterion.betterThan(numOf(45), numOf(50))); } |
IsHighestRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { HighestValueIndicator highest = new HighestValueIndicator(ref, barCount); Num highestVal = highest.getValue(index); Num refVal = ref.getValue(index); final boolean satisfied = !refVal.isNaN() && !highestVal.isNaN() && refVal.equals(highestVal); traceIsSatisfied(index, satisfied); return satisfied; } IsHighestRule(Indicator<Num> ref, int barCount); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); } | @Test public void isSatisfied() { assertTrue(rule.isSatisfied(0)); assertTrue(rule.isSatisfied(1)); assertFalse(rule.isSatisfied(2)); assertTrue(rule.isSatisfied(3)); assertFalse(rule.isSatisfied(4)); assertTrue(rule.isSatisfied(5)); assertFalse(rule.isSatisfied(6)); assertFalse(rule.isSatisfied(7)); assertTrue(rule.isSatisfied(8)); assertTrue(rule.isSatisfied(9)); } |
TotalLossCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return tradingRecord.getTrades().stream().filter(Trade::isClosed).map(trade -> calculate(series, trade)) .reduce(series.numOf(0), Num::plus); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); } | @Test public void calculateOnlyWithGainTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(2, series), Order.buyAt(3, series), Order.sellAt(5, series)); AnalysisCriterion profit = getCriterion(); assertNumEquals(0, profit.calculate(series, tradingRecord)); }
@Test public void calculateOnlyWithLossTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(1, series), Order.buyAt(2, series), Order.sellAt(5, series)); AnalysisCriterion profit = getCriterion(); assertNumEquals(-35, profit.calculate(series, tradingRecord)); }
@Test public void calculateProfitWithTradesThatStartSelling() { MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); TradingRecord tradingRecord = new BaseTradingRecord(Order.sellAt(0, series), Order.buyAt(1, series), Order.sellAt(2, series), Order.buyAt(5, series)); AnalysisCriterion profit = getCriterion(); assertNumEquals(-35, profit.calculate(series, tradingRecord)); } |
TotalLossCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); } | @Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(2.0), numOf(1.5))); assertFalse(criterion.betterThan(numOf(1.5), numOf(2.0))); } |
ValueAtRiskCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Returns returns = new Returns(series, tradingRecord, Returns.ReturnType.LOG); return calculateVaR(returns, confidence); } ValueAtRiskCriterion(Double confidence); @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); } | @Test public void calculateOnlyWithGainTrades() { series = new MockBarSeries(numFunction, 100d, 105d, 106d, 107d, 108d, 115d); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(2, series), Order.buyAt(3, series), Order.sellAt(5, series)); AnalysisCriterion varCriterion = getCriterion(); assertNumEquals(numOf(0.0), varCriterion.calculate(series, tradingRecord)); }
@Test public void calculateWithASimpleTrade() { series = new MockBarSeries(numFunction, 100d, 104d, 90d, 100d, 95d, 105d); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(2, series)); AnalysisCriterion varCriterion = getCriterion(); assertNumEquals(numOf(Math.log(90d / 104)), varCriterion.calculate(series, tradingRecord)); }
@Test public void calculateOnlyWithLossTrades() { series = new MockBarSeries(numFunction, 100d, 95d, 100d, 80d, 85d, 70d); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(1, series), Order.buyAt(2, series), Order.sellAt(5, series)); AnalysisCriterion varCriterion = getCriterion(); assertNumEquals(numOf(Math.log(80d / 100)), varCriterion.calculate(series, tradingRecord)); }
@Test public void calculateWithNoBarsShouldReturn0() { series = new MockBarSeries(numFunction, 100d, 95d, 100d, 80d, 85d, 70d); AnalysisCriterion varCriterion = getCriterion(); assertNumEquals(numOf(0), varCriterion.calculate(series, new BaseTradingRecord())); }
@Test public void calculateWithBuyAndHold() { series = new MockBarSeries(numFunction, 100d, 99d); Trade trade = new Trade(Order.buyAt(0, series), Order.sellAt(1, series)); AnalysisCriterion varCriterion = getCriterion(); assertNumEquals(numOf(Math.log(99d / 100)), varCriterion.calculate(series, trade)); } |
ValueAtRiskCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } ValueAtRiskCriterion(Double confidence); @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); } | @Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(-0.1), numOf(-0.2))); assertFalse(criterion.betterThan(numOf(-0.1), numOf(0.0))); } |
InSlopeRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { DifferenceIndicator diff = new DifferenceIndicator(ref, prev); Num val = diff.getValue(index); boolean minSlopeSatisfied = minSlope.isNaN() || val.isGreaterThanOrEqual(minSlope); boolean maxSlopeSatisfied = maxSlope.isNaN() || val.isLessThanOrEqual(maxSlope); boolean isNaN = minSlope.isNaN() && maxSlope.isNaN(); final boolean satisfied = minSlopeSatisfied && maxSlopeSatisfied && !isNaN; traceIsSatisfied(index, satisfied); return satisfied; } InSlopeRule(Indicator<Num> ref, Num minSlope); InSlopeRule(Indicator<Num> ref, Num minSlope, Num maxSlope); InSlopeRule(Indicator<Num> ref, int nthPrevious, Num maxSlope); InSlopeRule(Indicator<Num> ref, int nthPrevious, Num minSlope, Num maxSlope); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); } | @Test public void isSatisfied() { assertFalse(rulePositiveSlope.isSatisfied(0)); assertTrue(rulePositiveSlope.isSatisfied(1)); assertFalse(rulePositiveSlope.isSatisfied(2)); assertFalse(rulePositiveSlope.isSatisfied(9)); assertFalse(ruleNegativeSlope.isSatisfied(0)); assertFalse(ruleNegativeSlope.isSatisfied(1)); assertTrue(ruleNegativeSlope.isSatisfied(5)); assertFalse(ruleNegativeSlope.isSatisfied(9)); } |
NumberOfTradesCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return series.numOf(tradingRecord.getTradeCount()); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); } | @Test public void calculateWithNoTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); AnalysisCriterion buyAndHold = getCriterion(); assertNumEquals(0, buyAndHold.calculate(series, new BaseTradingRecord())); }
@Test public void calculateWithTwoTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(2, series), Order.buyAt(3, series), Order.sellAt(5, series)); AnalysisCriterion buyAndHold = getCriterion(); assertNumEquals(2, buyAndHold.calculate(series, tradingRecord)); }
@Test public void calculateWithOneTrade() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); Trade trade = new Trade(); AnalysisCriterion tradesCriterion = getCriterion(); assertNumEquals(1, tradesCriterion.calculate(series, trade)); } |
NumberOfTradesCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isLessThan(criterionValue2); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); } | @Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(3), numOf(6))); assertFalse(criterion.betterThan(numOf(7), numOf(4))); } |
TotalProfitCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return tradingRecord.getTrades().stream().map(trade -> calculateProfit(series, trade)).reduce(series.numOf(1), Num::multipliedBy); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); } | @Test public void calculateOnlyWithGainTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(2, series), Order.buyAt(3, series), Order.sellAt(5, series)); AnalysisCriterion profit = getCriterion(); assertNumEquals(1.10 * 1.05, profit.calculate(series, tradingRecord)); }
@Test public void calculateOnlyWithLossTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(1, series), Order.buyAt(2, series), Order.sellAt(5, series)); AnalysisCriterion profit = getCriterion(); assertNumEquals(0.95 * 0.7, profit.calculate(series, tradingRecord)); }
@Test public void calculateProfitWithTradesThatStartSelling() { MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); TradingRecord tradingRecord = new BaseTradingRecord(Order.sellAt(0, series), Order.buyAt(1, series), Order.sellAt(2, series), Order.buyAt(5, series)); AnalysisCriterion profit = getCriterion(); assertNumEquals((1 / 0.95) * (1 / 0.7), profit.calculate(series, tradingRecord)); }
@Test public void calculateWithNoTradesShouldReturn1() { MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); AnalysisCriterion profit = getCriterion(); assertNumEquals(1d, profit.calculate(series, new BaseTradingRecord())); }
@Test public void calculateWithOpenedTradeShouldReturn1() { MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); AnalysisCriterion profit = getCriterion(); Trade trade = new Trade(); assertNumEquals(1d, profit.calculate(series, trade)); trade.operate(0); assertNumEquals(1d, profit.calculate(series, trade)); } |
TotalProfitCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); } | @Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(2.0), numOf(1.5))); assertFalse(criterion.betterThan(numOf(1.5), numOf(2.0))); } |
OverIndicatorRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { final boolean satisfied = first.getValue(index).isGreaterThan(second.getValue(index)); traceIsSatisfied(index, satisfied); return satisfied; } OverIndicatorRule(Indicator<Num> indicator, Number threshold); OverIndicatorRule(Indicator<Num> indicator, Num threshold); OverIndicatorRule(Indicator<Num> first, Indicator<Num> second); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); } | @Test public void isSatisfied() { assertTrue(rule.isSatisfied(0)); assertTrue(rule.isSatisfied(1)); assertTrue(rule.isSatisfied(2)); assertFalse(rule.isSatisfied(3)); assertFalse(rule.isSatisfied(4)); assertFalse(rule.isSatisfied(5)); assertFalse(rule.isSatisfied(6)); assertTrue(rule.isSatisfied(7)); } |
LinearTransactionCostCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, Trade trade) { return getTradeCost(series, trade, series.numOf(initialAmount)); } LinearTransactionCostCriterion(double initialAmount, double a); LinearTransactionCostCriterion(double initialAmount, double a, double b); @Override Num calculate(BarSeries series, Trade trade); @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); } | @Test public void externalData() throws Exception { BarSeries xlsSeries = xls.getSeries(); TradingRecord xlsTradingRecord = xls.getTradingRecord(); Num value; value = getCriterion(1000d, 0.005, 0.2).calculate(xlsSeries, xlsTradingRecord); assertNumEquals(xls.getFinalCriterionValue(1000d, 0.005, 0.2).doubleValue(), value); assertNumEquals(843.5492, value); value = getCriterion(1000d, 0.1, 1.0).calculate(xlsSeries, xlsTradingRecord); assertNumEquals(xls.getFinalCriterionValue(1000d, 0.1, 1.0).doubleValue(), value); assertNumEquals(1122.4410, value); }
@Test public void dummyData() { MockBarSeries series = new MockBarSeries(numFunction, 100, 150, 200, 100, 50, 100); TradingRecord tradingRecord = new BaseTradingRecord(); Num criterion; tradingRecord.operate(0); tradingRecord.operate(1); criterion = getCriterion(1000d, 0.005, 0.2).calculate(series, tradingRecord); assertNumEquals(12.861, criterion); tradingRecord.operate(2); tradingRecord.operate(3); criterion = getCriterion(1000d, 0.005, 0.2).calculate(series, tradingRecord); assertNumEquals(24.3759, criterion); tradingRecord.operate(5); criterion = getCriterion(1000d, 0.005, 0.2).calculate(series, tradingRecord); assertNumEquals(28.2488, criterion); }
@Test public void fixedCost() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); TradingRecord tradingRecord = new BaseTradingRecord(); Num criterion; tradingRecord.operate(0); tradingRecord.operate(1); criterion = getCriterion(1000d, 0d, 1.3d).calculate(series, tradingRecord); assertNumEquals(2.6d, criterion); tradingRecord.operate(2); tradingRecord.operate(3); criterion = getCriterion(1000d, 0d, 1.3d).calculate(series, tradingRecord); assertNumEquals(5.2d, criterion); tradingRecord.operate(0); criterion = getCriterion(1000d, 0d, 1.3d).calculate(series, tradingRecord); assertNumEquals(6.5d, criterion); }
@Test public void fixedCostWithOneTrade() { MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); Trade trade = new Trade(); Num criterion; criterion = getCriterion(1000d, 0d, 0.75d).calculate(series, trade); assertNumEquals(0d, criterion); trade.operate(1); criterion = getCriterion(1000d, 0d, 0.75d).calculate(series, trade); assertNumEquals(0.75d, criterion); trade.operate(3); criterion = getCriterion(1000d, 0d, 0.75d).calculate(series, trade); assertNumEquals(1.5d, criterion); trade.operate(4); criterion = getCriterion(1000d, 0d, 0.75d).calculate(series, trade); assertNumEquals(1.5d, criterion); } |
LinearTransactionCostCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isLessThan(criterionValue2); } LinearTransactionCostCriterion(double initialAmount, double a); LinearTransactionCostCriterion(double initialAmount, double a, double b); @Override Num calculate(BarSeries series, Trade trade); @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); } | @Test public void betterThan() { AnalysisCriterion criterion = new LinearTransactionCostCriterion(1000, 0.5); assertTrue(criterion.betterThan(numOf(3.1), numOf(4.2))); assertFalse(criterion.betterThan(numOf(2.1), numOf(1.9))); } |
MaximumDrawdownCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { CashFlow cashFlow = new CashFlow(series, tradingRecord); return calculateMaximumDrawdown(series, cashFlow); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); } | @Test public void calculateWithNoTrades() { MockBarSeries series = new MockBarSeries(numFunction, 1, 2, 3, 6, 5, 20, 3); AnalysisCriterion mdd = getCriterion(); assertNumEquals(0d, mdd.calculate(series, new BaseTradingRecord())); }
@Test public void calculateWithOnlyGains() { MockBarSeries series = new MockBarSeries(numFunction, 1, 2, 3, 6, 8, 20, 3); AnalysisCriterion mdd = getCriterion(); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(1, series), Order.buyAt(2, series), Order.sellAt(5, series)); assertNumEquals(0d, mdd.calculate(series, tradingRecord)); }
@Test public void calculateShouldWork() { MockBarSeries series = new MockBarSeries(numFunction, 1, 2, 3, 6, 5, 20, 3); AnalysisCriterion mdd = getCriterion(); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(1, series), Order.buyAt(3, series), Order.sellAt(4, series), Order.buyAt(5, series), Order.sellAt(6, series)); assertNumEquals(.875d, mdd.calculate(series, tradingRecord)); }
@Test public void calculateWithNullSeriesSizeShouldReturn0() { MockBarSeries series = new MockBarSeries(numFunction, new double[] {}); AnalysisCriterion mdd = getCriterion(); assertNumEquals(0d, mdd.calculate(series, new BaseTradingRecord())); }
@Test public void withTradesThatSellBeforeBuying() { MockBarSeries series = new MockBarSeries(numFunction, 2, 1, 3, 5, 6, 3, 20); AnalysisCriterion mdd = getCriterion(); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(1, series), Order.buyAt(3, series), Order.sellAt(4, series), Order.sellAt(5, series), Order.buyAt(6, series)); assertNumEquals(3.8d, mdd.calculate(series, tradingRecord)); }
@Test public void withSimpleTrades() { MockBarSeries series = new MockBarSeries(numFunction, 1, 10, 5, 6, 1); AnalysisCriterion mdd = getCriterion(); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(1, series), Order.buyAt(1, series), Order.sellAt(2, series), Order.buyAt(2, series), Order.sellAt(3, series), Order.buyAt(3, series), Order.sellAt(4, series)); assertNumEquals(.9d, mdd.calculate(series, tradingRecord)); } |
WaitForRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { boolean satisfied = false; if (tradingRecord != null) { Order lastOrder = tradingRecord.getLastOrder(orderType); if (lastOrder != null) { int currentNumberOfBars = index - lastOrder.getIndex(); satisfied = currentNumberOfBars >= numberOfBars; } } traceIsSatisfied(index, satisfied); return satisfied; } WaitForRule(OrderType orderType, int numberOfBars); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); } | @Test public void waitForSinceLastBuyRuleIsSatisfied() { rule = new WaitForRule(Order.OrderType.BUY, 3); assertFalse(rule.isSatisfied(0, null)); assertFalse(rule.isSatisfied(1, tradingRecord)); tradingRecord.enter(10); assertFalse(rule.isSatisfied(10, tradingRecord)); assertFalse(rule.isSatisfied(11, tradingRecord)); assertFalse(rule.isSatisfied(12, tradingRecord)); assertTrue(rule.isSatisfied(13, tradingRecord)); assertTrue(rule.isSatisfied(14, tradingRecord)); tradingRecord.exit(15); assertTrue(rule.isSatisfied(15, tradingRecord)); assertTrue(rule.isSatisfied(16, tradingRecord)); tradingRecord.enter(17); assertFalse(rule.isSatisfied(17, tradingRecord)); assertFalse(rule.isSatisfied(18, tradingRecord)); assertFalse(rule.isSatisfied(19, tradingRecord)); assertTrue(rule.isSatisfied(20, tradingRecord)); }
@Test public void waitForSinceLastSellRuleIsSatisfied() { rule = new WaitForRule(Order.OrderType.SELL, 2); assertFalse(rule.isSatisfied(0, null)); assertFalse(rule.isSatisfied(1, tradingRecord)); tradingRecord.enter(10); assertFalse(rule.isSatisfied(10, tradingRecord)); assertFalse(rule.isSatisfied(11, tradingRecord)); assertFalse(rule.isSatisfied(12, tradingRecord)); assertFalse(rule.isSatisfied(13, tradingRecord)); tradingRecord.exit(15); assertFalse(rule.isSatisfied(15, tradingRecord)); assertFalse(rule.isSatisfied(16, tradingRecord)); assertTrue(rule.isSatisfied(17, tradingRecord)); tradingRecord.enter(17); assertTrue(rule.isSatisfied(17, tradingRecord)); assertTrue(rule.isSatisfied(18, tradingRecord)); tradingRecord.exit(20); assertFalse(rule.isSatisfied(20, tradingRecord)); assertFalse(rule.isSatisfied(21, tradingRecord)); assertTrue(rule.isSatisfied(22, tradingRecord)); } |
MaximumDrawdownCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isLessThan(criterionValue2); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); } | @Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(0.9), numOf(1.5))); assertFalse(criterion.betterThan(numOf(1.2), numOf(0.4))); } |
ProfitLossCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return tradingRecord.getTrades().stream().filter(Trade::isClosed).map(trade -> calculate(series, trade)) .reduce(series.numOf(0), Num::plus); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); } | @Test public void calculateOnlyWithGainTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series, series.numOf(50)), Order.sellAt(2, series, series.numOf(50)), Order.buyAt(3, series, series.numOf(50)), Order.sellAt(5, series, series.numOf(50))); AnalysisCriterion profit = getCriterion(); assertNumEquals(500 + 250, profit.calculate(series, tradingRecord)); }
@Test public void calculateOnlyWithLossTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series, series.numOf(50)), Order.sellAt(1, series, series.numOf(50)), Order.buyAt(2, series, series.numOf(50)), Order.sellAt(5, series, series.numOf(50))); AnalysisCriterion profit = getCriterion(); assertNumEquals(-250 - 1500, profit.calculate(series, tradingRecord)); }
@Test public void calculateShortOnlyWithGainTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); TradingRecord tradingRecord = new BaseTradingRecord(Order.sellAt(0, series, series.numOf(50)), Order.buyAt(2, series, series.numOf(50)), Order.sellAt(3, series, series.numOf(50)), Order.buyAt(5, series, series.numOf(50))); AnalysisCriterion profit = getCriterion(); assertNumEquals(-(500 + 250), profit.calculate(series, tradingRecord)); }
@Test public void calculateShortOnlyWithLossTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); TradingRecord tradingRecord = new BaseTradingRecord(Order.sellAt(0, series, series.numOf(50)), Order.buyAt(1, series, series.numOf(50)), Order.sellAt(2, series, series.numOf(50)), Order.buyAt(5, series, series.numOf(50))); AnalysisCriterion profit = getCriterion(); assertNumEquals(250 + 1500, profit.calculate(series, tradingRecord)); } |
ProfitLossCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); } | @Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(5000), numOf(4500))); assertFalse(criterion.betterThan(numOf(4500), numOf(5000))); } |
ZeroCostModel implements CostModel { public Num calculate(Trade trade) { return calculate(trade, 0); } ZeroCostModel(); Num calculate(Trade trade); Num calculate(Trade trade, int currentIndex); Num calculate(Num price, Num amount); boolean equals(CostModel otherModel); } | @Test public void calculatePerTrade() { ZeroCostModel model = new ZeroCostModel(); int holdingPeriod = 2; Order entry = Order.buyAt(0, DoubleNum.valueOf(100), DoubleNum.valueOf(1), model); Order exit = Order.sellAt(holdingPeriod, DoubleNum.valueOf(110), DoubleNum.valueOf(1), model); Trade trade = new Trade(entry, exit, model, model); Num cost = model.calculate(trade, holdingPeriod); assertNumEquals(cost, DoubleNum.valueOf(0)); }
@Test public void calculatePerPrice() { ZeroCostModel model = new ZeroCostModel(); Num cost = model.calculate(DoubleNum.valueOf(100), DoubleNum.valueOf(1)); assertNumEquals(cost, DoubleNum.valueOf(0)); } |
ZeroCostModel implements CostModel { public boolean equals(CostModel otherModel) { boolean equality = false; if (this.getClass().equals(otherModel.getClass())) { equality = true; } return equality; } ZeroCostModel(); Num calculate(Trade trade); Num calculate(Trade trade, int currentIndex); Num calculate(Num price, Num amount); boolean equals(CostModel otherModel); } | @Test public void testEquality() { ZeroCostModel model = new ZeroCostModel(); CostModel modelSame = new ZeroCostModel(); CostModel modelOther = new LinearTransactionCostModel(0.1); boolean equality = model.equals(modelSame); boolean inequality = model.equals(modelOther); assertTrue(equality); assertFalse(inequality); } |
LinearBorrowingCostModel implements CostModel { public Num calculate(Num price, Num amount) { return price.numOf(0); } LinearBorrowingCostModel(double feePerPeriod); Num calculate(Num price, Num amount); Num calculate(Trade trade); Num calculate(Trade trade, int currentIndex); boolean equals(CostModel otherModel); } | @Test public void calculateZeroTest() { Num price = DoubleNum.valueOf(100); Num amount = DoubleNum.valueOf(2); Num cost = borrowingModel.calculate(price, amount); assertNumEquals(DoubleNum.valueOf(0), cost); }
@Test public void calculateBuyTrade() { int holdingPeriod = 2; Order entry = Order.buyAt(0, DoubleNum.valueOf(100), DoubleNum.valueOf(1)); Order exit = Order.sellAt(holdingPeriod, DoubleNum.valueOf(110), DoubleNum.valueOf(1)); Trade trade = new Trade(entry, exit, new ZeroCostModel(), borrowingModel); Num costsFromTrade = trade.getHoldingCost(); Num costsFromModel = borrowingModel.calculate(trade, holdingPeriod); assertNumEquals(costsFromModel, costsFromTrade); assertNumEquals(costsFromModel, DoubleNum.valueOf(0)); }
@Test public void calculateSellTrade() { int holdingPeriod = 2; Order entry = Order.sellAt(0, DoubleNum.valueOf(100), DoubleNum.valueOf(1)); Order exit = Order.buyAt(holdingPeriod, DoubleNum.valueOf(110), DoubleNum.valueOf(1)); Trade trade = new Trade(entry, exit, new ZeroCostModel(), borrowingModel); Num costsFromTrade = trade.getHoldingCost(); Num costsFromModel = borrowingModel.calculate(trade, holdingPeriod); assertNumEquals(costsFromModel, costsFromTrade); assertNumEquals(costsFromModel, DoubleNum.valueOf(2)); }
@Test public void calculateOpenSellTrade() { int currentIndex = 4; Trade trade = new Trade(Order.OrderType.SELL, new ZeroCostModel(), borrowingModel); trade.operate(0, DoubleNum.valueOf(100), DoubleNum.valueOf(1)); Num costsFromTrade = trade.getHoldingCost(currentIndex); Num costsFromModel = borrowingModel.calculate(trade, currentIndex); assertNumEquals(costsFromModel, costsFromTrade); assertNumEquals(costsFromModel, DoubleNum.valueOf(4)); } |
LinearBorrowingCostModel implements CostModel { public boolean equals(CostModel otherModel) { boolean equality = false; if (this.getClass().equals(otherModel.getClass())) { equality = ((LinearBorrowingCostModel) otherModel).feePerPeriod == this.feePerPeriod; } return equality; } LinearBorrowingCostModel(double feePerPeriod); Num calculate(Num price, Num amount); Num calculate(Trade trade); Num calculate(Trade trade, int currentIndex); boolean equals(CostModel otherModel); } | @Test public void testEquality() { LinearBorrowingCostModel model = new LinearBorrowingCostModel(0.1); CostModel modelSameClass = new LinearBorrowingCostModel(0.2); CostModel modelSameFee = new LinearBorrowingCostModel(0.1); CostModel modelOther = new ZeroCostModel(); boolean equality = model.equals(modelSameFee); boolean inequality1 = model.equals(modelSameClass); boolean inequality2 = model.equals(modelOther); assertTrue(equality); assertFalse(inequality1); assertFalse(inequality2); } |
LinearTransactionCostModel implements CostModel { public Num calculate(Trade trade, int currentIndex) { return this.calculate(trade); } LinearTransactionCostModel(double feePerTrade); Num calculate(Trade trade, int currentIndex); Num calculate(Trade trade); Num calculate(Num price, Num amount); boolean equals(CostModel otherModel); } | @Test public void calculateSingleOrderCost() { Num price = DoubleNum.valueOf(100); Num amount = DoubleNum.valueOf(2); Num cost = transactionModel.calculate(price, amount); assertNumEquals(DoubleNum.valueOf(2), cost); }
@Test public void calculateBuyTrade() { int holdingPeriod = 2; Order entry = Order.buyAt(0, DoubleNum.valueOf(100), DoubleNum.valueOf(1), transactionModel); Order exit = Order.sellAt(holdingPeriod, DoubleNum.valueOf(110), DoubleNum.valueOf(1), transactionModel); Trade trade = new Trade(entry, exit, transactionModel, new ZeroCostModel()); Num costFromBuy = entry.getCost(); Num costFromSell = exit.getCost(); Num costsFromModel = transactionModel.calculate(trade, holdingPeriod); assertNumEquals(costsFromModel, costFromBuy.plus(costFromSell)); assertNumEquals(costsFromModel, DoubleNum.valueOf(2.1)); assertNumEquals(costFromBuy, DoubleNum.valueOf(1)); }
@Test public void calculateSellTrade() { int holdingPeriod = 2; Order entry = Order.sellAt(0, DoubleNum.valueOf(100), DoubleNum.valueOf(1), transactionModel); Order exit = Order.buyAt(holdingPeriod, DoubleNum.valueOf(110), DoubleNum.valueOf(1), transactionModel); Trade trade = new Trade(entry, exit, transactionModel, new ZeroCostModel()); Num costFromBuy = entry.getCost(); Num costFromSell = exit.getCost(); Num costsFromModel = transactionModel.calculate(trade, holdingPeriod); assertNumEquals(costsFromModel, costFromBuy.plus(costFromSell)); assertNumEquals(costsFromModel, DoubleNum.valueOf(2.1)); assertNumEquals(costFromBuy, DoubleNum.valueOf(1)); }
@Test public void calculateOpenSellTrade() { int currentIndex = 4; Trade trade = new Trade(Order.OrderType.BUY, transactionModel, new ZeroCostModel()); trade.operate(0, DoubleNum.valueOf(100), DoubleNum.valueOf(1)); Num costsFromModel = transactionModel.calculate(trade, currentIndex); assertNumEquals(costsFromModel, DoubleNum.valueOf(1)); } |
LinearTransactionCostModel implements CostModel { public boolean equals(CostModel otherModel) { boolean equality = false; if (this.getClass().equals(otherModel.getClass())) { equality = ((LinearTransactionCostModel) otherModel).feePerTrade == this.feePerTrade; } return equality; } LinearTransactionCostModel(double feePerTrade); Num calculate(Trade trade, int currentIndex); Num calculate(Trade trade); Num calculate(Num price, Num amount); boolean equals(CostModel otherModel); } | @Test public void testEquality() { LinearTransactionCostModel model = new LinearTransactionCostModel(0.1); CostModel modelSameClass = new LinearTransactionCostModel(0.2); CostModel modelSameFee = new LinearTransactionCostModel(0.1); CostModel modelOther = new ZeroCostModel(); boolean equality = model.equals(modelSameFee); boolean inequality1 = model.equals(modelSameClass); boolean inequality2 = model.equals(modelOther); assertTrue(equality); assertFalse(inequality1); assertFalse(inequality2); } |
OrRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { final boolean satisfied = rule1.isSatisfied(index, tradingRecord) || rule2.isSatisfied(index, tradingRecord); traceIsSatisfied(index, satisfied); return satisfied; } OrRule(Rule rule1, Rule rule2); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); Rule getRule1(); Rule getRule2(); } | @Test public void isSatisfied() { assertTrue(satisfiedRule.or(BooleanRule.FALSE).isSatisfied(0)); assertTrue(BooleanRule.FALSE.or(satisfiedRule).isSatisfied(0)); assertFalse(unsatisfiedRule.or(BooleanRule.FALSE).isSatisfied(0)); assertFalse(BooleanRule.FALSE.or(unsatisfiedRule).isSatisfied(0)); assertTrue(satisfiedRule.or(BooleanRule.TRUE).isSatisfied(10)); assertTrue(BooleanRule.TRUE.or(satisfiedRule).isSatisfied(10)); assertTrue(unsatisfiedRule.or(BooleanRule.TRUE).isSatisfied(10)); assertTrue(BooleanRule.TRUE.or(unsatisfiedRule).isSatisfied(10)); } |
Trade implements Serializable { public boolean isOpened() { return (entry != null) && (exit == null); } Trade(); Trade(OrderType startingType); Trade(OrderType startingType, CostModel transactionCostModel, CostModel holdingCostModel); Trade(Order entry, Order exit); Trade(Order entry, Order exit, CostModel transactionCostModel, CostModel holdingCostModel); Order getEntry(); Order getExit(); @Override boolean equals(Object obj); @Override int hashCode(); Order operate(int index); Order operate(int index, Num price, Num amount); boolean isClosed(); boolean isOpened(); boolean isNew(); @Override String toString(); Num getProfit(); Num getProfit(int finalIndex, Num finalPrice); Num getTradeCost(int finalIndex); Num getTradeCost(); Num getHoldingCost(); Num getHoldingCost(int finalIndex); } | @Test public void whenNewShouldNotExit() { assertFalse(newTrade.isOpened()); } |
Trade implements Serializable { public Order operate(int index) { return operate(index, NaN, NaN); } Trade(); Trade(OrderType startingType); Trade(OrderType startingType, CostModel transactionCostModel, CostModel holdingCostModel); Trade(Order entry, Order exit); Trade(Order entry, Order exit, CostModel transactionCostModel, CostModel holdingCostModel); Order getEntry(); Order getExit(); @Override boolean equals(Object obj); @Override int hashCode(); Order operate(int index); Order operate(int index, Num price, Num amount); boolean isClosed(); boolean isOpened(); boolean isNew(); @Override String toString(); Num getProfit(); Num getProfit(int finalIndex, Num finalPrice); Num getTradeCost(int finalIndex); Num getTradeCost(); Num getHoldingCost(); Num getHoldingCost(int finalIndex); } | @Test(expected = IllegalStateException.class) public void whenExitIndexIsLessThanEntryIndexShouldThrowException() { newTrade.operate(3); newTrade.operate(1); }
@Test public void testEqualsForEntryOrders() { Trade trLeft = newTrade; Trade trRightEquals = new Trade(); Trade trRightNotEquals = new Trade(); assertEquals(OrderType.BUY, trRightNotEquals.operate(2).getType()); assertNotEquals(trLeft, trRightNotEquals); assertEquals(OrderType.BUY, trLeft.operate(1).getType()); assertEquals(OrderType.BUY, trRightEquals.operate(1).getType()); assertEquals(trLeft, trRightEquals); assertNotEquals(trLeft, trRightNotEquals); }
@Test public void testEqualsForExitOrders() { Trade trLeft = newTrade; Trade trRightEquals = new Trade(); Trade trRightNotEquals = new Trade(); assertEquals(OrderType.BUY, trLeft.operate(1).getType()); assertEquals(OrderType.BUY, trRightEquals.operate(1).getType()); assertEquals(OrderType.BUY, trRightNotEquals.operate(1).getType()); assertEquals(OrderType.SELL, trRightNotEquals.operate(3).getType()); assertNotEquals(trLeft, trRightNotEquals); assertEquals(OrderType.SELL, trLeft.operate(2).getType()); assertEquals(OrderType.SELL, trRightEquals.operate(2).getType()); assertEquals(trLeft, trRightEquals); assertNotEquals(trLeft, trRightNotEquals); } |
Trade implements Serializable { @Override public String toString() { return "Entry: " + entry + " exit: " + exit; } Trade(); Trade(OrderType startingType); Trade(OrderType startingType, CostModel transactionCostModel, CostModel holdingCostModel); Trade(Order entry, Order exit); Trade(Order entry, Order exit, CostModel transactionCostModel, CostModel holdingCostModel); Order getEntry(); Order getExit(); @Override boolean equals(Object obj); @Override int hashCode(); Order operate(int index); Order operate(int index, Num price, Num amount); boolean isClosed(); boolean isOpened(); boolean isNew(); @Override String toString(); Num getProfit(); Num getProfit(int finalIndex, Num finalPrice); Num getTradeCost(int finalIndex); Num getTradeCost(); Num getHoldingCost(); Num getHoldingCost(int finalIndex); } | @Test public void overrideToString() { assertEquals(trEquals1.toString(), trEquals2.toString()); assertNotEquals(trEquals1.toString(), trNotEquals1.toString()); assertNotEquals(trEquals1.toString(), trNotEquals2.toString()); } |
PrecisionNum implements Num { private PrecisionNum(String val) { delegate = new BigDecimal(val); int precision = Math.max(delegate.precision(), DEFAULT_PRECISION); mathContext = new MathContext(precision, RoundingMode.HALF_UP); } private PrecisionNum(String val); private PrecisionNum(String val, int precision); private PrecisionNum(short val); private PrecisionNum(int val); private PrecisionNum(long val); private PrecisionNum(float val); private PrecisionNum(double val); private PrecisionNum(BigDecimal val, int precision); static PrecisionNum valueOf(String val); static PrecisionNum valueOf(String val, int precision); static PrecisionNum valueOf(short val); static PrecisionNum valueOf(int val); static PrecisionNum valueOf(long val); static PrecisionNum valueOf(float val); static PrecisionNum valueOf(BigDecimal val); static PrecisionNum valueOf(BigDecimal val, int precision); static PrecisionNum valueOf(double val); static PrecisionNum valueOf(PrecisionNum val); static PrecisionNum valueOf(Number val); @Override Function<Number, Num> function(); @Override BigDecimal getDelegate(); MathContext getMathContext(); @Override String getName(); @Override Num plus(Num augend); @Override Num minus(Num subtrahend); @Override Num multipliedBy(Num multiplicand); @Override Num dividedBy(Num divisor); @Override Num remainder(Num divisor); Num floor(); Num ceil(); @Override Num pow(int n); Num sqrt(); @Override Num sqrt(int precision); Num log(); @Override Num abs(); @Override boolean isZero(); @Override boolean isPositive(); @Override boolean isPositiveOrZero(); @Override boolean isNegative(); @Override boolean isNegativeOrZero(); @Override boolean isEqual(Num other); boolean matches(Num other, int precision); boolean matches(Num other, Num delta); @Override boolean isGreaterThan(Num other); @Override boolean isGreaterThanOrEqual(Num other); @Override boolean isLessThan(Num other); @Override boolean isLessThanOrEqual(Num other); @Override int compareTo(Num other); @Override Num min(Num other); @Override Num max(Num other); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override Num pow(Num n); } | @Test public void precisionNumTest() { init(); test(); } |
PrecisionNum implements Num { public static PrecisionNum valueOf(String val) { if (val.equalsIgnoreCase("NAN")) { throw new NumberFormatException(); } return new PrecisionNum(val); } private PrecisionNum(String val); private PrecisionNum(String val, int precision); private PrecisionNum(short val); private PrecisionNum(int val); private PrecisionNum(long val); private PrecisionNum(float val); private PrecisionNum(double val); private PrecisionNum(BigDecimal val, int precision); static PrecisionNum valueOf(String val); static PrecisionNum valueOf(String val, int precision); static PrecisionNum valueOf(short val); static PrecisionNum valueOf(int val); static PrecisionNum valueOf(long val); static PrecisionNum valueOf(float val); static PrecisionNum valueOf(BigDecimal val); static PrecisionNum valueOf(BigDecimal val, int precision); static PrecisionNum valueOf(double val); static PrecisionNum valueOf(PrecisionNum val); static PrecisionNum valueOf(Number val); @Override Function<Number, Num> function(); @Override BigDecimal getDelegate(); MathContext getMathContext(); @Override String getName(); @Override Num plus(Num augend); @Override Num minus(Num subtrahend); @Override Num multipliedBy(Num multiplicand); @Override Num dividedBy(Num divisor); @Override Num remainder(Num divisor); Num floor(); Num ceil(); @Override Num pow(int n); Num sqrt(); @Override Num sqrt(int precision); Num log(); @Override Num abs(); @Override boolean isZero(); @Override boolean isPositive(); @Override boolean isPositiveOrZero(); @Override boolean isNegative(); @Override boolean isNegativeOrZero(); @Override boolean isEqual(Num other); boolean matches(Num other, int precision); boolean matches(Num other, Num delta); @Override boolean isGreaterThan(Num other); @Override boolean isGreaterThanOrEqual(Num other); @Override boolean isLessThan(Num other); @Override boolean isLessThanOrEqual(Num other); @Override int compareTo(Num other); @Override Num min(Num other); @Override Num max(Num other); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override Num pow(Num n); } | @Test(expected = NumberFormatException.class) public void testValueOfForFloatNaNShouldThrowNumberFormatException() { PrecisionNum.valueOf(Float.NaN); }
@Test(expected = NumberFormatException.class) public void testValueOfForDoubleNaNShouldThrowNumberFormatException() { PrecisionNum.valueOf(Double.NaN); } |
BaseBarSeriesAggregator implements BarSeriesAggregator { @Override public BarSeries aggregate(BarSeries series, String aggregatedSeriesName) { final List<Bar> aggregatedBars = barAggregator.aggregate(series.getBarData()); return new BaseBarSeries(aggregatedSeriesName, aggregatedBars); } BaseBarSeriesAggregator(BarAggregator barAggregator); @Override BarSeries aggregate(BarSeries series, String aggregatedSeriesName); } | @Test public void testAggregateWithNewName() { final List<Bar> bars = new LinkedList<>(); final ZonedDateTime time = ZonedDateTime.of(2019, 6, 12, 4, 1, 0, 0, ZoneId.systemDefault()); final Bar bar0 = new MockBar(time, 1d, 2d, 3d, 4d, 5d, 6d, 7, numFunction); final Bar bar1 = new MockBar(time.plusDays(1), 2d, 3d, 3d, 4d, 5d, 6d, 7, numFunction); final Bar bar2 = new MockBar(time.plusDays(2), 3d, 4d, 4d, 5d, 6d, 7d, 7, numFunction); bars.add(bar0); bars.add(bar1); bars.add(bar2); final BarSeries barSeries = new BaseBarSeries("name", bars); final BarSeries aggregated = baseBarSeriesAggregator.aggregate(barSeries, "newName"); assertEquals("newName", aggregated.getName()); assertEquals(2, aggregated.getBarCount()); assertSame(bar0, aggregated.getBar(0)); assertSame(bar2, aggregated.getBar(1)); }
@Test public void testAggregateWithTheSameName() { final List<Bar> bars = new LinkedList<>(); final ZonedDateTime time = ZonedDateTime.of(2019, 6, 12, 4, 1, 0, 0, ZoneId.systemDefault()); final Bar bar0 = new MockBar(time, 1d, 2d, 3d, 4d, 5d, 6d, 7, numFunction); final Bar bar1 = new MockBar(time.plusDays(1), 2d, 3d, 3d, 4d, 5d, 6d, 7, numFunction); final Bar bar2 = new MockBar(time.plusDays(2), 3d, 4d, 4d, 5d, 6d, 7d, 7, numFunction); bars.add(bar0); bars.add(bar1); bars.add(bar2); final BarSeries barSeries = new BaseBarSeries("name", bars); final BarSeries aggregated = baseBarSeriesAggregator.aggregate(barSeries); assertEquals("name", aggregated.getName()); assertEquals(2, aggregated.getBarCount()); assertSame(bar0, aggregated.getBar(0)); assertSame(bar2, aggregated.getBar(1)); } |
JustOnceRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { if (satisfied) { return false; } else if (rule == null) { satisfied = true; traceIsSatisfied(index, true); return true; } this.satisfied = this.rule.isSatisfied(index, tradingRecord); return this.satisfied; } JustOnceRule(Rule rule); JustOnceRule(); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); } | @Test public void isSatisfied() { assertTrue(rule.isSatisfied(10)); assertFalse(rule.isSatisfied(11)); assertFalse(rule.isSatisfied(12)); assertFalse(rule.isSatisfied(13)); assertFalse(rule.isSatisfied(14)); }
@Test public void isSatisfiedInReverseOrder() { assertTrue(rule.isSatisfied(5)); assertFalse(rule.isSatisfied(2)); assertFalse(rule.isSatisfied(1)); assertFalse(rule.isSatisfied(0)); }
@Test public void isSatisfiedWithInnerSatisfiedRule() { JustOnceRule rule = new JustOnceRule(new BooleanRule(true)); assertTrue(rule.isSatisfied(5)); assertFalse(rule.isSatisfied(2)); assertFalse(rule.isSatisfied(1)); assertFalse(rule.isSatisfied(0)); }
@Test public void isSatisfiedWithInnerNonSatisfiedRule() { JustOnceRule rule = new JustOnceRule(new BooleanRule(false)); assertFalse(rule.isSatisfied(5)); assertFalse(rule.isSatisfied(2)); assertFalse(rule.isSatisfied(1)); assertFalse(rule.isSatisfied(0)); }
@Test public void isSatisfiedWithInnerRule() { JustOnceRule rule = new JustOnceRule(new FixedRule(1, 3, 5)); assertFalse(rule.isSatisfied(0)); assertTrue(rule.isSatisfied(1)); assertFalse(rule.isSatisfied(2)); assertFalse(rule.isSatisfied(3)); assertFalse(rule.isSatisfied(4)); assertFalse(rule.isSatisfied(5)); assertFalse(rule.isSatisfied(1)); } |
DurationBarAggregator implements BarAggregator { @Override public List<Bar> aggregate(List<Bar> bars) { final List<Bar> aggregated = new ArrayList<>(); if (bars.isEmpty()) { return aggregated; } final Duration actualDur = bars.iterator().next().getTimePeriod(); final boolean isMultiplication = timePeriod.getSeconds() % actualDur.getSeconds() == 0; if (!isMultiplication) { throw new IllegalArgumentException( "Cannot aggregate bars: the new timePeriod must be a multiplication of the actual timePeriod."); } int i = 0; final Num zero = bars.iterator().next().getOpenPrice().numOf(0); while (i < bars.size()) { Bar bar = bars.get(i); final ZonedDateTime beginTime = bar.getBeginTime(); final Num open = bar.getOpenPrice(); Num high = bar.getHighPrice(); Num low = bar.getLowPrice(); Num close = null; Num volume = zero; Num amount = zero; Duration sumDur = Duration.ZERO; while (sumDur.compareTo(timePeriod) < 0) { if (i < bars.size()) { bar = bars.get(i); if (high == null || bar.getHighPrice().isGreaterThan(high)) { high = bar.getHighPrice(); } if (low == null || bar.getLowPrice().isLessThan(low)) { low = bar.getLowPrice(); } close = bar.getClosePrice(); volume = volume.plus(bar.getVolume()); amount = amount.plus(bar.getAmount()); } sumDur = sumDur.plus(actualDur); i++; } if (!onlyFinalBars || i <= bars.size()) { final Bar aggregatedBar = new BaseBar(timePeriod, beginTime.plus(timePeriod), open, high, low, close, volume, amount); aggregated.add(aggregatedBar); } } return aggregated; } DurationBarAggregator(Duration timePeriod); DurationBarAggregator(Duration timePeriod, boolean onlyFinalBars); @Override List<Bar> aggregate(List<Bar> bars); } | @Test public void upscaledTo5DayBars() { final DurationBarAggregator barAggregator = new DurationBarAggregator(Duration.ofDays(5), true); final List<Bar> bars = barAggregator.aggregate(getOneDayBars()); assertEquals(3, bars.size()); final Bar bar1 = bars.get(0); final Num num1 = bar1.getOpenPrice(); TestUtils.assertNumEquals(num1.numOf(1), bar1.getOpenPrice()); TestUtils.assertNumEquals(num1.numOf(6), bar1.getHighPrice()); TestUtils.assertNumEquals(num1.numOf(4), bar1.getLowPrice()); TestUtils.assertNumEquals(num1.numOf(9), bar1.getClosePrice()); TestUtils.assertNumEquals(num1.numOf(33), bar1.getVolume()); final Bar bar2 = bars.get(1); final Num num2 = bar2.getOpenPrice(); TestUtils.assertNumEquals(num2.numOf(6), bar2.getOpenPrice()); TestUtils.assertNumEquals(num2.numOf(91), bar2.getHighPrice()); TestUtils.assertNumEquals(num2.numOf(4), bar2.getLowPrice()); TestUtils.assertNumEquals(num2.numOf(10), bar2.getClosePrice()); TestUtils.assertNumEquals(num2.numOf(260), bar2.getVolume()); Bar bar3 = bars.get(2); Num num3 = bar3.getOpenPrice(); TestUtils.assertNumEquals(num3.numOf(4), bar3.getOpenPrice()); TestUtils.assertNumEquals(num3.numOf(991), bar3.getHighPrice()); TestUtils.assertNumEquals(num3.numOf(43), bar3.getLowPrice()); TestUtils.assertNumEquals(num3.numOf(10), bar3.getClosePrice()); TestUtils.assertNumEquals(num3.numOf(1010), bar3.getVolume()); }
@Test public void upscaledTo10DayBars() { final DurationBarAggregator barAggregator = new DurationBarAggregator(Duration.ofDays(10), true); final List<Bar> bars = barAggregator.aggregate(getOneDayBars()); assertEquals(1, bars.size()); final Bar bar1 = bars.get(0); final Num num1 = bar1.getOpenPrice(); TestUtils.assertNumEquals(num1.numOf(1), bar1.getOpenPrice()); TestUtils.assertNumEquals(num1.numOf(91), bar1.getHighPrice()); TestUtils.assertNumEquals(num1.numOf(4), bar1.getLowPrice()); TestUtils.assertNumEquals(num1.numOf(10), bar1.getClosePrice()); TestUtils.assertNumEquals(num1.numOf(293), bar1.getVolume()); }
@Test public void upscaledTo10DayBarsNotOnlyFinalBars() { final DurationBarAggregator barAggregator = new DurationBarAggregator(Duration.ofDays(10), false); final List<Bar> bars = barAggregator.aggregate(getOneDayBars()); assertEquals(2, bars.size()); } |
StrategyExecutionLogging { public static void main(String[] args) { loadLoggerConfiguration(); BarSeries series = CsvTradesLoader.loadBitstampSeries(); Strategy strategy = CCICorrectionStrategy.buildStrategy(series); BarSeriesManager seriesManager = new BarSeriesManager(series); seriesManager.run(strategy); unloadLoggerConfiguration(); } static void main(String[] args); } | @Test public void test() { StrategyExecutionLogging.main(null); } |
RSI2Strategy { public static void main(String[] args) { BarSeries series = CsvTradesLoader.loadBitstampSeries(); Strategy strategy = buildStrategy(series); BarSeriesManager seriesManager = new BarSeriesManager(series); TradingRecord tradingRecord = seriesManager.run(strategy); System.out.println("Number of trades for the strategy: " + tradingRecord.getTradeCount()); System.out.println( "Total profit for the strategy: " + new TotalProfitCriterion().calculate(series, tradingRecord)); } static Strategy buildStrategy(BarSeries series); static void main(String[] args); } | @Test public void test() { RSI2Strategy.main(null); } |
GlobalExtremaStrategy { public static void main(String[] args) { BarSeries series = CsvTradesLoader.loadBitstampSeries(); Strategy strategy = buildStrategy(series); BarSeriesManager seriesManager = new BarSeriesManager(series); TradingRecord tradingRecord = seriesManager.run(strategy); System.out.println("Number of trades for the strategy: " + tradingRecord.getTradeCount()); System.out.println( "Total profit for the strategy: " + new TotalProfitCriterion().calculate(series, tradingRecord)); } static Strategy buildStrategy(BarSeries series); static void main(String[] args); } | @Test public void test() { GlobalExtremaStrategy.main(null); } |
CCICorrectionStrategy { public static void main(String[] args) { BarSeries series = CsvTradesLoader.loadBitstampSeries(); Strategy strategy = buildStrategy(series); BarSeriesManager seriesManager = new BarSeriesManager(series); TradingRecord tradingRecord = seriesManager.run(strategy); System.out.println("Number of trades for the strategy: " + tradingRecord.getTradeCount()); System.out.println( "Total profit for the strategy: " + new TotalProfitCriterion().calculate(series, tradingRecord)); } static Strategy buildStrategy(BarSeries series); static void main(String[] args); } | @Test public void test() { CCICorrectionStrategy.main(null); } |
MovingMomentumStrategy { public static void main(String[] args) { BarSeries series = CsvTradesLoader.loadBitstampSeries(); Strategy strategy = buildStrategy(series); BarSeriesManager seriesManager = new BarSeriesManager(series); TradingRecord tradingRecord = seriesManager.run(strategy); System.out.println("Number of trades for the strategy: " + tradingRecord.getTradeCount()); System.out.println( "Total profit for the strategy: " + new TotalProfitCriterion().calculate(series, tradingRecord)); } static Strategy buildStrategy(BarSeries series); static void main(String[] args); } | @Test public void test() { MovingMomentumStrategy.main(null); } |
Quickstart { public static void main(String[] args) { BarSeries series = CsvTradesLoader.loadBitstampSeries(); Num firstClosePrice = series.getBar(0).getClosePrice(); System.out.println("First close price: " + firstClosePrice.doubleValue()); ClosePriceIndicator closePrice = new ClosePriceIndicator(series); System.out.println(firstClosePrice.isEqual(closePrice.getValue(0))); SMAIndicator shortSma = new SMAIndicator(closePrice, 5); System.out.println("5-bars-SMA value at the 42nd index: " + shortSma.getValue(42).doubleValue()); SMAIndicator longSma = new SMAIndicator(closePrice, 30); Rule buyingRule = new CrossedUpIndicatorRule(shortSma, longSma) .or(new CrossedDownIndicatorRule(closePrice, 800)); Rule sellingRule = new CrossedDownIndicatorRule(shortSma, longSma) .or(new StopLossRule(closePrice, series.numOf(3))).or(new StopGainRule(closePrice, series.numOf(2))); BarSeriesManager seriesManager = new BarSeriesManager(series); TradingRecord tradingRecord = seriesManager.run(new BaseStrategy(buyingRule, sellingRule)); System.out.println("Number of trades for our strategy: " + tradingRecord.getTradeCount()); AnalysisCriterion profitTradesRatio = new AverageProfitableTradesCriterion(); System.out.println("Profitable trades ratio: " + profitTradesRatio.calculate(series, tradingRecord)); AnalysisCriterion rewardRiskRatio = new RewardRiskRatioCriterion(); System.out.println("Reward-risk ratio: " + rewardRiskRatio.calculate(series, tradingRecord)); AnalysisCriterion vsBuyAndHold = new VersusBuyAndHoldCriterion(new TotalProfitCriterion()); System.out.println("Our profit vs buy-and-hold profit: " + vsBuyAndHold.calculate(series, tradingRecord)); } static void main(String[] args); } | @Test public void test() { Quickstart.main(null); } |
BuildBarSeries { @SuppressWarnings("unused") public static void main(String[] args) { BarSeries a = buildAndAddData(); System.out.println("a: " + a.getBar(0).getClosePrice().getName()); BaseBarSeriesBuilder.setDefaultFunction(DoubleNum::valueOf); a = buildAndAddData(); System.out.println("a: " + a.getBar(0).getClosePrice().getName()); BarSeries b = buildWithDouble(); BarSeries c = buildWithBigDecimal(); BarSeries d = buildManually(); BarSeries e = buildManuallyDoubleNum(); BarSeries f = buildManuallyAndAddBarManually(); BarSeries g = buildAndAddBarsFromList(); } @SuppressWarnings("unused") static void main(String[] args); } | @Test public void test() { BuildBarSeries.main(null); } |
IsRisingRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { if (minStrenght >= 1) { minStrenght = 0.99; } int count = 0; for (int i = Math.max(0, index - barCount + 1); i <= index; i++) { if (ref.getValue(i).isGreaterThan(ref.getValue(Math.max(0, i - 1)))) { count += 1; } } double ratio = count / (double) barCount; final boolean satisfied = ratio >= minStrenght; traceIsSatisfied(index, satisfied); return satisfied; } IsRisingRule(Indicator<Num> ref, int barCount); IsRisingRule(Indicator<Num> ref, int barCount, double minStrenght); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); } | @Test public void isSatisfied() { assertFalse(rule.isSatisfied(0)); assertFalse(rule.isSatisfied(1)); assertFalse(rule.isSatisfied(2)); assertTrue(rule.isSatisfied(3)); assertTrue(rule.isSatisfied(4)); assertTrue(rule.isSatisfied(5)); assertFalse(rule.isSatisfied(6)); assertFalse(rule.isSatisfied(7)); assertFalse(rule.isSatisfied(8)); assertTrue(rule.isSatisfied(9)); } |
WalkForward { public static void main(String[] args) { BarSeries series = CsvTradesLoader.loadBitstampSeries(); List<BarSeries> subseries = splitSeries(series, Duration.ofHours(6), Duration.ofDays(7)); Map<Strategy, String> strategies = buildStrategiesMap(series); AnalysisCriterion profitCriterion = new TotalProfitCriterion(); for (BarSeries slice : subseries) { System.out.println("Sub-series: " + slice.getSeriesPeriodDescription()); BarSeriesManager sliceManager = new BarSeriesManager(slice); for (Map.Entry<Strategy, String> entry : strategies.entrySet()) { Strategy strategy = entry.getKey(); String name = entry.getValue(); TradingRecord tradingRecord = sliceManager.run(strategy); Num profit = profitCriterion.calculate(slice, tradingRecord); System.out.println("\tProfit for " + name + ": " + profit); } Strategy bestStrategy = profitCriterion.chooseBest(sliceManager, new ArrayList<Strategy>(strategies.keySet())); System.out.println("\t\t--> Best strategy: " + strategies.get(bestStrategy) + "\n"); } } static List<Integer> getSplitBeginIndexes(BarSeries series, Duration splitDuration); static BarSeries subseries(BarSeries series, int beginIndex, Duration duration); static List<BarSeries> splitSeries(BarSeries series, Duration splitDuration, Duration sliceDuration); static Map<Strategy, String> buildStrategiesMap(BarSeries series); static void main(String[] args); } | @Test public void test() { WalkForward.main(null); } |
CandlestickChart { public static void main(String[] args) { BarSeries series = CsvTradesLoader.loadBitstampSeries(); OHLCDataset ohlcDataset = createOHLCDataset(series); TimeSeriesCollection xyDataset = createAdditionalDataset(series); JFreeChart chart = ChartFactory.createCandlestickChart("Bitstamp BTC price", "Time", "USD", ohlcDataset, true); CandlestickRenderer renderer = new CandlestickRenderer(); renderer.setAutoWidthMethod(CandlestickRenderer.WIDTHMETHOD_SMALLEST); XYPlot plot = chart.getXYPlot(); plot.setRenderer(renderer); int index = 1; plot.setDataset(index, xyDataset); plot.mapDatasetToRangeAxis(index, 0); XYLineAndShapeRenderer renderer2 = new XYLineAndShapeRenderer(true, false); renderer2.setSeriesPaint(index, Color.blue); plot.setRenderer(index, renderer2); plot.setRangeGridlinePaint(Color.lightGray); plot.setBackgroundPaint(Color.white); NumberAxis numberAxis = (NumberAxis) plot.getRangeAxis(); numberAxis.setAutoRangeIncludesZero(false); plot.setDatasetRenderingOrder(DatasetRenderingOrder.FORWARD); displayChart(chart); } static void main(String[] args); } | @Test public void test() { CandlestickChart.main(null); } |
IndicatorsToChart { public static void main(String[] args) { BarSeries series = CsvBarsLoader.loadAppleIncSeries(); ClosePriceIndicator closePrice = new ClosePriceIndicator(series); EMAIndicator avg14 = new EMAIndicator(closePrice, 14); StandardDeviationIndicator sd14 = new StandardDeviationIndicator(closePrice, 14); BollingerBandsMiddleIndicator middleBBand = new BollingerBandsMiddleIndicator(avg14); BollingerBandsLowerIndicator lowBBand = new BollingerBandsLowerIndicator(middleBBand, sd14); BollingerBandsUpperIndicator upBBand = new BollingerBandsUpperIndicator(middleBBand, sd14); TimeSeriesCollection dataset = new TimeSeriesCollection(); dataset.addSeries(buildChartBarSeries(series, closePrice, "Apple Inc. (AAPL) - NASDAQ GS")); dataset.addSeries(buildChartBarSeries(series, lowBBand, "Low Bollinger Band")); dataset.addSeries(buildChartBarSeries(series, upBBand, "High Bollinger Band")); JFreeChart chart = ChartFactory.createTimeSeriesChart("Apple Inc. 2013 Close Prices", "Date", "Price Per Unit", dataset, true, true, false ); XYPlot plot = (XYPlot) chart.getPlot(); DateAxis axis = (DateAxis) plot.getDomainAxis(); axis.setDateFormatOverride(new SimpleDateFormat("yyyy-MM-dd")); displayChart(chart); } static void main(String[] args); } | @Test public void test() { IndicatorsToChart.main(null); } |
IndicatorsToCsv { public static void main(String[] args) { BarSeries series = CsvTradesLoader.loadBitstampSeries(); ClosePriceIndicator closePrice = new ClosePriceIndicator(series); TypicalPriceIndicator typicalPrice = new TypicalPriceIndicator(series); PriceVariationIndicator priceVariation = new PriceVariationIndicator(series); SMAIndicator shortSma = new SMAIndicator(closePrice, 8); SMAIndicator longSma = new SMAIndicator(closePrice, 20); EMAIndicator shortEma = new EMAIndicator(closePrice, 8); EMAIndicator longEma = new EMAIndicator(closePrice, 20); PPOIndicator ppo = new PPOIndicator(closePrice, 12, 26); ROCIndicator roc = new ROCIndicator(closePrice, 100); RSIIndicator rsi = new RSIIndicator(closePrice, 14); WilliamsRIndicator williamsR = new WilliamsRIndicator(series, 20); ATRIndicator atr = new ATRIndicator(series, 20); StandardDeviationIndicator sd = new StandardDeviationIndicator(closePrice, 14); StringBuilder sb = new StringBuilder( "timestamp,close,typical,variation,sma8,sma20,ema8,ema20,ppo,roc,rsi,williamsr,atr,sd\n"); final int nbBars = series.getBarCount(); for (int i = 0; i < nbBars; i++) { sb.append(series.getBar(i).getEndTime()).append(',').append(closePrice.getValue(i)).append(',') .append(typicalPrice.getValue(i)).append(',').append(priceVariation.getValue(i)).append(',') .append(shortSma.getValue(i)).append(',').append(longSma.getValue(i)).append(',') .append(shortEma.getValue(i)).append(',').append(longEma.getValue(i)).append(',') .append(ppo.getValue(i)).append(',').append(roc.getValue(i)).append(',').append(rsi.getValue(i)) .append(',').append(williamsR.getValue(i)).append(',').append(atr.getValue(i)).append(',') .append(sd.getValue(i)).append('\n'); } BufferedWriter writer = null; try { writer = new BufferedWriter(new FileWriter(new File("target", "indicators.csv"))); writer.write(sb.toString()); } catch (IOException ioe) { Logger.getLogger(IndicatorsToCsv.class.getName()).log(Level.SEVERE, "Unable to write CSV file", ioe); } finally { try { if (writer != null) { writer.close(); } } catch (IOException ioe) { ioe.printStackTrace(); } } } static void main(String[] args); } | @Test public void test() { IndicatorsToCsv.main(null); } |
StrategyAnalysis { public static void main(String[] args) { BarSeries series = CsvTradesLoader.loadBitstampSeries(); Strategy strategy = MovingMomentumStrategy.buildStrategy(series); BarSeriesManager seriesManager = new BarSeriesManager(series); TradingRecord tradingRecord = seriesManager.run(strategy); TotalProfitCriterion totalProfit = new TotalProfitCriterion(); System.out.println("Total profit: " + totalProfit.calculate(series, tradingRecord)); System.out.println("Number of bars: " + new NumberOfBarsCriterion().calculate(series, tradingRecord)); System.out .println("Average profit (per bar): " + new AverageProfitCriterion().calculate(series, tradingRecord)); System.out.println("Number of trades: " + new NumberOfTradesCriterion().calculate(series, tradingRecord)); System.out.println( "Profitable trades ratio: " + new AverageProfitableTradesCriterion().calculate(series, tradingRecord)); System.out.println("Maximum drawdown: " + new MaximumDrawdownCriterion().calculate(series, tradingRecord)); System.out.println("Reward-risk ratio: " + new RewardRiskRatioCriterion().calculate(series, tradingRecord)); System.out.println("Total transaction cost (from $1000): " + new LinearTransactionCostCriterion(1000, 0.005).calculate(series, tradingRecord)); System.out.println("Buy-and-hold: " + new BuyAndHoldCriterion().calculate(series, tradingRecord)); System.out.println("Custom strategy profit vs buy-and-hold strategy profit: " + new VersusBuyAndHoldCriterion(totalProfit).calculate(series, tradingRecord)); } static void main(String[] args); } | @Test public void test() { StrategyAnalysis.main(null); } |
TradeCost { public static void main(String[] args) { BarSeries series = CsvTradesLoader.loadBitstampSeries(); Strategy strategy = buildShortSellingMomentumStrategy(series); double feePerTrade = 0.0005; double borrowingFee = 0.00001; CostModel transactionCostModel = new LinearTransactionCostModel(feePerTrade); CostModel borrowingCostModel = new LinearBorrowingCostModel(borrowingFee); BarSeriesManager seriesManager = new BarSeriesManager(series, transactionCostModel, borrowingCostModel); Order.OrderType entryOrder = Order.OrderType.SELL; TradingRecord tradingRecord = seriesManager.run(strategy, entryOrder); DecimalFormat df = new DecimalFormat("##.##"); System.out.println("------------ Borrowing Costs ------------"); tradingRecord.getTrades() .forEach(trade -> System.out.println( "Borrowing cost for " + df.format(trade.getExit().getIndex() - trade.getEntry().getIndex()) + " periods is: " + df.format(trade.getHoldingCost().doubleValue()))); System.out.println("------------ Transaction Costs ------------"); tradingRecord.getTrades() .forEach(trade -> System.out.println("Transaction cost for selling: " + df.format(trade.getEntry().getCost().doubleValue()) + " -- Transaction cost for buying: " + df.format(trade.getExit().getCost().doubleValue()))); } static void main(String[] args); } | @Test public void test() { TradeCost.main(null); } |
CashFlowToChart { public static void main(String[] args) { BarSeries series = CsvTradesLoader.loadBitstampSeries(); Strategy strategy = MovingMomentumStrategy.buildStrategy(series); BarSeriesManager seriesManager = new BarSeriesManager(series); TradingRecord tradingRecord = seriesManager.run(strategy); CashFlow cashFlow = new CashFlow(series, tradingRecord); TimeSeriesCollection datasetAxis1 = new TimeSeriesCollection(); datasetAxis1.addSeries(buildChartBarSeries(series, new ClosePriceIndicator(series), "Bitstamp Bitcoin (BTC)")); TimeSeriesCollection datasetAxis2 = new TimeSeriesCollection(); datasetAxis2.addSeries(buildChartBarSeries(series, cashFlow, "Cash Flow")); JFreeChart chart = ChartFactory.createTimeSeriesChart("Bitstamp BTC", "Date", "Price", datasetAxis1, true, true, false ); XYPlot plot = (XYPlot) chart.getPlot(); DateAxis axis = (DateAxis) plot.getDomainAxis(); axis.setDateFormatOverride(new SimpleDateFormat("MM-dd HH:mm")); addCashFlowAxis(plot, datasetAxis2); displayChart(chart); } static void main(String[] args); } | @Test public void test() { CashFlowToChart.main(null); } |
BuyAndSellSignalsToChart { public static void main(String[] args) { BarSeries series = CsvTradesLoader.loadBitstampSeries(); Strategy strategy = MovingMomentumStrategy.buildStrategy(series); TimeSeriesCollection dataset = new TimeSeriesCollection(); dataset.addSeries(buildChartTimeSeries(series, new ClosePriceIndicator(series), "Bitstamp Bitcoin (BTC)")); JFreeChart chart = ChartFactory.createTimeSeriesChart("Bitstamp BTC", "Date", "Price", dataset, true, true, false ); XYPlot plot = (XYPlot) chart.getPlot(); DateAxis axis = (DateAxis) plot.getDomainAxis(); axis.setDateFormatOverride(new SimpleDateFormat("MM-dd HH:mm")); addBuySellSignals(series, strategy, plot); displayChart(chart); } static void main(String[] args); } | @Test public void test() { BuyAndSellSignalsToChart.main(null); } |
CompareNumTypes { public static void main(String args[]) { BaseBarSeriesBuilder barSeriesBuilder = new BaseBarSeriesBuilder(); BarSeries seriesD = barSeriesBuilder.withName("Sample Series Double ").withNumTypeOf(DoubleNum::valueOf) .build(); BarSeries seriesP = barSeriesBuilder.withName("Sample Series PrecisionNum 32") .withNumTypeOf(PrecisionNum::valueOf).build(); BarSeries seriesPH = barSeriesBuilder.withName("Sample Series PrecisionNum 256") .withNumTypeOf(number -> PrecisionNum.valueOf(number.toString(), 256)).build(); int[] randoms = new Random().ints(NUMBARS, 80, 100).toArray(); for (int i = 0; i < randoms.length; i++) { ZonedDateTime date = ZonedDateTime.now().minusSeconds(NUMBARS - i); seriesD.addBar(date, randoms[i], randoms[i] + 21, randoms[i] - 21, randoms[i] - 5); seriesP.addBar(date, randoms[i], randoms[i] + 21, randoms[i] - 21, randoms[i] - 5); seriesPH.addBar(date, randoms[i], randoms[i] + 21, randoms[i] - 21, randoms[i] - 5); } Num D = PrecisionNum.valueOf(test(seriesD).toString(), 256); Num P = PrecisionNum.valueOf(test(seriesP).toString(), 256); Num standard = PrecisionNum.valueOf(test(seriesPH).toString(), 256); System.out.println(seriesD.getName() + " error: " + D.minus(standard).dividedBy(standard).multipliedBy(PrecisionNum.valueOf(100))); System.out.println(seriesP.getName() + " error: " + P.minus(standard).dividedBy(standard).multipliedBy(PrecisionNum.valueOf(100))); } static void main(String args[]); static Num test(BarSeries series); } | @Test public void test() { CompareNumTypes.main(null); } |
TradingBotOnMovingBarSeries { public static void main(String[] args) throws InterruptedException { System.out.println("********************** Initialization **********************"); BarSeries series = initMovingBarSeries(20); Strategy strategy = buildStrategy(series); TradingRecord tradingRecord = new BaseTradingRecord(); System.out.println("************************************************************"); for (int i = 0; i < 50; i++) { Thread.sleep(30); Bar newBar = generateRandomBar(); System.out.println("------------------------------------------------------\n" + "Bar " + i + " added, close price = " + newBar.getClosePrice().doubleValue()); series.addBar(newBar); int endIndex = series.getEndIndex(); if (strategy.shouldEnter(endIndex)) { System.out.println("Strategy should ENTER on " + endIndex); boolean entered = tradingRecord.enter(endIndex, newBar.getClosePrice(), PrecisionNum.valueOf(10)); if (entered) { Order entry = tradingRecord.getLastEntry(); System.out.println("Entered on " + entry.getIndex() + " (price=" + entry.getNetPrice().doubleValue() + ", amount=" + entry.getAmount().doubleValue() + ")"); } } else if (strategy.shouldExit(endIndex)) { System.out.println("Strategy should EXIT on " + endIndex); boolean exited = tradingRecord.exit(endIndex, newBar.getClosePrice(), PrecisionNum.valueOf(10)); if (exited) { Order exit = tradingRecord.getLastExit(); System.out.println("Exited on " + exit.getIndex() + " (price=" + exit.getNetPrice().doubleValue() + ", amount=" + exit.getAmount().doubleValue() + ")"); } } } } static void main(String[] args); } | @Test public void test() throws InterruptedException { TradingBotOnMovingBarSeries.main(null); } |
CsvTradesLoader { public static void main(String[] args) { BarSeries series = CsvTradesLoader.loadBitstampSeries(); System.out.println("Series: " + series.getName() + " (" + series.getSeriesPeriodDescription() + ")"); System.out.println("Number of bars: " + series.getBarCount()); System.out.println("First bar: \n" + "\tVolume: " + series.getBar(0).getVolume() + "\n" + "\tNumber of trades: " + series.getBar(0).getTrades() + "\n" + "\tClose price: " + series.getBar(0).getClosePrice()); } static BarSeries loadBitstampSeries(); static void main(String[] args); } | @Test public void test() { CsvTradesLoader.main(null); } |
CsvBarsLoader { public static void main(String[] args) { BarSeries series = CsvBarsLoader.loadAppleIncSeries(); System.out.println("Series: " + series.getName() + " (" + series.getSeriesPeriodDescription() + ")"); System.out.println("Number of bars: " + series.getBarCount()); System.out.println("First bar: \n" + "\tVolume: " + series.getBar(0).getVolume() + "\n" + "\tOpen price: " + series.getBar(0).getOpenPrice() + "\n" + "\tClose price: " + series.getBar(0).getClosePrice()); } static BarSeries loadAppleIncSeries(); static BarSeries loadCsvSeries(String filename); static void main(String[] args); } | @Test public void test() { CsvBarsLoader.main(null); } |
TrailingStopLossRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { boolean satisfied = false; if (tradingRecord != null) { Trade currentTrade = tradingRecord.getCurrentTrade(); if (currentTrade.isOpened()) { Num currentPrice = priceIndicator.getValue(index); int tradeIndex = currentTrade.getEntry().getIndex(); if (currentTrade.getEntry().isBuy()) { satisfied = isBuySatisfied(currentPrice, index, tradeIndex); } else { satisfied = isSellSatisfied(currentPrice, index, tradeIndex); } } } traceIsSatisfied(index, satisfied); return satisfied; } TrailingStopLossRule(PriceIndicator priceIndicator, Num lossPercentage, int barCount); TrailingStopLossRule(PriceIndicator priceIndicator, Num lossPercentage); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); Num getCurrentStopLossLimitActivation(); } | @Test public void isSatisfiedForBuyForBarCount() { BaseTradingRecord tradingRecord = new BaseTradingRecord(OrderType.BUY); ClosePriceIndicator closePrice = new ClosePriceIndicator( new MockBarSeries(numFunction, 100, 110, 120, 130, 120, 117.00, 117.00, 130, 116.99)); TrailingStopLossRule rule = new TrailingStopLossRule(closePrice, numOf(10), 3); assertFalse(rule.isSatisfied(0, null)); assertFalse(rule.isSatisfied(1, tradingRecord)); tradingRecord.enter(2, numOf(114), numOf(1)); assertFalse(rule.isSatisfied(2, tradingRecord)); assertFalse(rule.isSatisfied(3, tradingRecord)); assertFalse(rule.isSatisfied(4, tradingRecord)); assertTrue(rule.isSatisfied(5, tradingRecord)); assertFalse(rule.isSatisfied(6, tradingRecord)); tradingRecord.exit(7); tradingRecord.enter(7, numOf(128), numOf(1)); assertFalse(rule.isSatisfied(7, tradingRecord)); assertTrue(rule.isSatisfied(8, tradingRecord)); }
@Test public void isSatisfiedForSellForBarCount() { BaseTradingRecord tradingRecord = new BaseTradingRecord(OrderType.SELL); ClosePriceIndicator closePrice = new ClosePriceIndicator( new MockBarSeries(numFunction, 100, 90, 80, 70, 70, 73, 77.00, 90, 120, 132.01)); TrailingStopLossRule rule = new TrailingStopLossRule(closePrice, numOf(10), 3); assertFalse(rule.isSatisfied(0, null)); assertFalse(rule.isSatisfied(1, tradingRecord)); tradingRecord.enter(2, numOf(84), numOf(1)); assertFalse(rule.isSatisfied(2, tradingRecord)); assertFalse(rule.isSatisfied(3, tradingRecord)); assertFalse(rule.isSatisfied(4, tradingRecord)); assertFalse(rule.isSatisfied(5, tradingRecord)); assertTrue(rule.isSatisfied(6, tradingRecord)); tradingRecord.exit(7); tradingRecord.enter(7, numOf(91), numOf(1)); assertFalse(rule.isSatisfied(7, tradingRecord)); assertTrue(rule.isSatisfied(8, tradingRecord)); } |
XorRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { final boolean satisfied = rule1.isSatisfied(index, tradingRecord) ^ rule2.isSatisfied(index, tradingRecord); traceIsSatisfied(index, satisfied); return satisfied; } XorRule(Rule rule1, Rule rule2); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); Rule getRule1(); Rule getRule2(); } | @Test public void isSatisfied() { assertTrue(satisfiedRule.xor(BooleanRule.FALSE).isSatisfied(0)); assertTrue(BooleanRule.FALSE.xor(satisfiedRule).isSatisfied(0)); assertFalse(unsatisfiedRule.xor(BooleanRule.FALSE).isSatisfied(0)); assertFalse(BooleanRule.FALSE.xor(unsatisfiedRule).isSatisfied(0)); assertFalse(satisfiedRule.xor(BooleanRule.TRUE).isSatisfied(10)); assertFalse(BooleanRule.TRUE.xor(satisfiedRule).isSatisfied(10)); assertTrue(unsatisfiedRule.xor(BooleanRule.TRUE).isSatisfied(10)); assertTrue(BooleanRule.TRUE.xor(unsatisfiedRule).isSatisfied(10)); } |
IsFallingRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { if (minStrenght >= 1) { minStrenght = 0.99; } int count = 0; for (int i = Math.max(0, index - barCount + 1); i <= index; i++) { if (ref.getValue(i).isLessThan(ref.getValue(Math.max(0, i - 1)))) { count += 1; } } double ratio = count / (double) barCount; final boolean satisfied = ratio >= minStrenght; traceIsSatisfied(index, satisfied); return satisfied; } IsFallingRule(Indicator<Num> ref, int barCount); IsFallingRule(Indicator<Num> ref, int barCount, double minStrenght); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); } | @Test public void isSatisfied() { assertFalse(rule.isSatisfied(0)); assertFalse(rule.isSatisfied(1)); assertFalse(rule.isSatisfied(2)); assertTrue(rule.isSatisfied(3)); assertTrue(rule.isSatisfied(4)); assertTrue(rule.isSatisfied(5)); assertTrue(rule.isSatisfied(6)); assertTrue(rule.isSatisfied(7)); assertFalse(rule.isSatisfied(8)); assertFalse(rule.isSatisfied(9)); } |
StopLossRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { boolean satisfied = false; if (tradingRecord != null) { Trade currentTrade = tradingRecord.getCurrentTrade(); if (currentTrade.isOpened()) { Num entryPrice = currentTrade.getEntry().getNetPrice(); Num currentPrice = closePrice.getValue(index); if (currentTrade.getEntry().isBuy()) { satisfied = isBuyStopSatisfied(entryPrice, currentPrice); } else { satisfied = isSellStopSatisfied(entryPrice, currentPrice); } } } traceIsSatisfied(index, satisfied); return satisfied; } StopLossRule(ClosePriceIndicator closePrice, Number lossPercentage); StopLossRule(ClosePriceIndicator closePrice, Num lossPercentage); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); } | @Test public void isSatisfiedWorksForBuy() { final TradingRecord tradingRecord = new BaseTradingRecord(Order.OrderType.BUY); final Num tradedAmount = numOf(1); StopLossRule rule = new StopLossRule(closePrice, numOf(5)); assertFalse(rule.isSatisfied(0, null)); assertFalse(rule.isSatisfied(1, tradingRecord)); tradingRecord.enter(2, numOf(114), tradedAmount); assertFalse(rule.isSatisfied(2, tradingRecord)); assertFalse(rule.isSatisfied(3, tradingRecord)); assertTrue(rule.isSatisfied(4, tradingRecord)); tradingRecord.exit(5); tradingRecord.enter(5, numOf(128), tradedAmount); assertFalse(rule.isSatisfied(5, tradingRecord)); assertTrue(rule.isSatisfied(6, tradingRecord)); assertTrue(rule.isSatisfied(7, tradingRecord)); }
@Test public void isSatisfiedWorksForSell() { final TradingRecord tradingRecord = new BaseTradingRecord(Order.OrderType.SELL); final Num tradedAmount = numOf(1); StopLossRule rule = new StopLossRule(closePrice, numOf(5)); assertFalse(rule.isSatisfied(0, null)); assertFalse(rule.isSatisfied(1, tradingRecord)); tradingRecord.enter(1, numOf(108), tradedAmount); assertFalse(rule.isSatisfied(1, tradingRecord)); assertFalse(rule.isSatisfied(2, tradingRecord)); assertTrue(rule.isSatisfied(3, tradingRecord)); tradingRecord.exit(4); tradingRecord.enter(2, numOf(114), tradedAmount); assertFalse(rule.isSatisfied(2, tradingRecord)); assertTrue(rule.isSatisfied(3, tradingRecord)); assertFalse(rule.isSatisfied(4, tradingRecord)); assertTrue(rule.isSatisfied(5, tradingRecord)); } |
StopGainRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { boolean satisfied = false; if (tradingRecord != null) { Trade currentTrade = tradingRecord.getCurrentTrade(); if (currentTrade.isOpened()) { Num entryPrice = currentTrade.getEntry().getNetPrice(); Num currentPrice = closePrice.getValue(index); if (currentTrade.getEntry().isBuy()) { satisfied = isBuyGainSatisfied(entryPrice, currentPrice); } else { satisfied = isSellGainSatisfied(entryPrice, currentPrice); } } } traceIsSatisfied(index, satisfied); return satisfied; } StopGainRule(ClosePriceIndicator closePrice, Number gainPercentage); StopGainRule(ClosePriceIndicator closePrice, Num gainPercentage); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); } | @Test public void isSatisfiedWorksForBuy() { final TradingRecord tradingRecord = new BaseTradingRecord(Order.OrderType.BUY); final Num tradedAmount = numOf(1); StopGainRule rule = new StopGainRule(closePrice, numOf(30)); assertFalse(rule.isSatisfied(0, null)); assertFalse(rule.isSatisfied(1, tradingRecord)); tradingRecord.enter(2, numOf(108), tradedAmount); assertFalse(rule.isSatisfied(2, tradingRecord)); assertFalse(rule.isSatisfied(3, tradingRecord)); assertTrue(rule.isSatisfied(4, tradingRecord)); tradingRecord.exit(5); tradingRecord.enter(5, numOf(118), tradedAmount); assertFalse(rule.isSatisfied(5, tradingRecord)); assertTrue(rule.isSatisfied(6, tradingRecord)); assertTrue(rule.isSatisfied(7, tradingRecord)); }
@Test public void isSatisfiedWorksForSell() { final TradingRecord tradingRecord = new BaseTradingRecord(Order.OrderType.SELL); final Num tradedAmount = numOf(1); StopGainRule rule = new StopGainRule(closePrice, numOf(10)); assertFalse(rule.isSatisfied(0, null)); assertFalse(rule.isSatisfied(1, tradingRecord)); tradingRecord.enter(7, numOf(178), tradedAmount); assertFalse(rule.isSatisfied(7, tradingRecord)); assertFalse(rule.isSatisfied(8, tradingRecord)); assertTrue(rule.isSatisfied(9, tradingRecord)); tradingRecord.exit(10); tradingRecord.enter(3, numOf(119), tradedAmount); assertFalse(rule.isSatisfied(3, tradingRecord)); assertFalse(rule.isSatisfied(2, tradingRecord)); assertTrue(rule.isSatisfied(1, tradingRecord)); assertTrue(rule.isSatisfied(10, tradingRecord)); } |
CrossedUpIndicatorRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { final boolean satisfied = cross.getValue(index); traceIsSatisfied(index, satisfied); return satisfied; } CrossedUpIndicatorRule(Indicator<Num> indicator, Number threshold); CrossedUpIndicatorRule(Indicator<Num> indicator, Num threshold); CrossedUpIndicatorRule(Indicator<Num> first, Indicator<Num> second); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); Indicator<Num> getLow(); Indicator<Num> getUp(); } | @Test public void isSatisfied() { assertFalse(rule.isSatisfied(0)); assertFalse(rule.isSatisfied(1)); assertFalse(rule.isSatisfied(2)); assertTrue(rule.isSatisfied(3)); assertFalse(rule.isSatisfied(4)); assertTrue(rule.isSatisfied(5)); assertFalse(rule.isSatisfied(6)); assertFalse(rule.isSatisfied(7)); } |
AroonUpIndicator extends CachedIndicator<Num> { @Override public String toString() { return getClass().getSimpleName() + " barCount: " + barCount; } AroonUpIndicator(Indicator<Num> maxValueIndicator, int barCount); AroonUpIndicator(BarSeries series, int barCount); @Override String toString(); } | @Test public void onlyNaNValues() { BaseBarSeries series = new BaseBarSeries("NaN test"); for (long i = 0; i <= 1000; i++) { series.addBar(ZonedDateTime.now().plusDays(i), NaN, NaN, NaN, NaN, NaN); } AroonUpIndicator aroonUpIndicator = new AroonUpIndicator(series, 5); for (int i = series.getBeginIndex(); i <= series.getEndIndex(); i++) { assertEquals(NaN.toString(), aroonUpIndicator.getValue(i).toString()); } }
@Test public void naNValuesInIntervall() { BaseBarSeries series = new BaseBarSeries("NaN test"); for (long i = 0; i <= 10; i++) { Num maxPrice = i % 2 == 0 ? series.numOf(i) : NaN; series.addBar(ZonedDateTime.now().plusDays(i), NaN, maxPrice, NaN, NaN, NaN); } AroonUpIndicator aroonUpIndicator = new AroonUpIndicator(series, 5); for (int i = series.getBeginIndex(); i <= series.getEndIndex(); i++) { if (i % 2 != 0) { assertEquals(NaN.toString(), aroonUpIndicator.getValue(i).toString()); } else { assertNumEquals(aroonUpIndicator.getValue(i).toString(), series.numOf(100)); } } } |
CachedIndicator extends AbstractIndicator<T> { @Override public T getValue(int index) { BarSeries series = getBarSeries(); if (series == null) { return calculate(index); } final int removedBarsCount = series.getRemovedBarsCount(); final int maximumResultCount = series.getMaximumBarCount(); T result; if (index < removedBarsCount) { log.trace("{}: result from bar {} already removed from cache, use {}-th instead", getClass().getSimpleName(), index, removedBarsCount); increaseLengthTo(removedBarsCount, maximumResultCount); highestResultIndex = removedBarsCount; result = results.get(0); if (result == null) { result = calculate(0); results.set(0, result); } } else { if (index == series.getEndIndex()) { result = calculate(index); } else { increaseLengthTo(index, maximumResultCount); if (index > highestResultIndex) { highestResultIndex = index; result = calculate(index); results.set(results.size() - 1, result); } else { int resultInnerIndex = results.size() - 1 - (highestResultIndex - index); result = results.get(resultInnerIndex); if (result == null) { result = calculate(index); results.set(resultInnerIndex, result); } } } } return result; } CachedIndicator(BarSeries series); CachedIndicator(Indicator<?> indicator); @Override T getValue(int index); } | @Test public void ifCacheWorks() { SMAIndicator sma = new SMAIndicator(new ClosePriceIndicator(series), 3); Num firstTime = sma.getValue(4); Num secondTime = sma.getValue(4); assertEquals(firstTime, secondTime); }
@Test public void getValueWithNullBarSeries() { ConstantIndicator<Num> constant = new ConstantIndicator<>( new BaseBarSeriesBuilder().withNumTypeOf(numFunction).build(), numFunction.apply(10)); assertEquals(numFunction.apply(10), constant.getValue(0)); assertEquals(numFunction.apply(10), constant.getValue(100)); assertNotNull(constant.getBarSeries()); SMAIndicator sma = new SMAIndicator(constant, 10); assertEquals(numFunction.apply(10), sma.getValue(0)); assertEquals(numFunction.apply(10), sma.getValue(100)); assertNotNull(sma.getBarSeries()); }
@Test public void getValueWithCacheLengthIncrease() { double[] data = new double[200]; Arrays.fill(data, 10); SMAIndicator sma = new SMAIndicator(new ClosePriceIndicator(new MockBarSeries(numFunction, data)), 100); assertNumEquals(10, sma.getValue(105)); }
@Test public void getValueWithOldResultsRemoval() { double[] data = new double[20]; Arrays.fill(data, 1); BarSeries barSeries = new MockBarSeries(numFunction, data); SMAIndicator sma = new SMAIndicator(new ClosePriceIndicator(barSeries), 10); assertNumEquals(1, sma.getValue(5)); assertNumEquals(1, sma.getValue(10)); barSeries.setMaximumBarCount(12); assertNumEquals(1, sma.getValue(19)); }
@Test public void getValueOnResultsCalculatedFromRemovedBarsShouldReturnFirstRemainingResult() { BarSeries barSeries = new MockBarSeries(numFunction, 1, 1, 1, 1, 1); barSeries.setMaximumBarCount(3); assertEquals(2, barSeries.getRemovedBarsCount()); SMAIndicator sma = new SMAIndicator(new ClosePriceIndicator(barSeries), 2); for (int i = 0; i < 5; i++) { assertNumEquals(1, sma.getValue(i)); } }
@Test public void recursiveCachedIndicatorOnMovingBarSeriesShouldNotCauseStackOverflow() { series = new MockBarSeries(numFunction); series.setMaximumBarCount(5); assertEquals(5, series.getBarCount()); ZLEMAIndicator zlema = new ZLEMAIndicator(new ClosePriceIndicator(series), 1); try { assertNumEquals(4996, zlema.getValue(8)); } catch (Throwable t) { fail(t.getMessage()); } }
@Test public void leaveLastBarUncached() { BarSeries barSeries = new MockBarSeries(numFunction); ClosePriceIndicator closePrice = new ClosePriceIndicator(barSeries); assertNumEquals(5000, closePrice.getValue(barSeries.getEndIndex())); barSeries.getLastBar().addTrade(numOf(10), numOf(5)); assertNumEquals(5, closePrice.getValue(barSeries.getEndIndex())); }
@Test public void leaveBarsBeforeLastBarCached() { BarSeries barSeries = new MockBarSeries(numFunction); ClosePriceIndicator closePrice = new ClosePriceIndicator(barSeries); assertNumEquals(2, closePrice.getValue(1)); barSeries.getBar(1).addTrade(numOf(10), numOf(5)); assertNumEquals(2, closePrice.getValue(1)); } |
UnderIndicatorRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { final boolean satisfied = first.getValue(index).isLessThan(second.getValue(index)); traceIsSatisfied(index, satisfied); return satisfied; } UnderIndicatorRule(Indicator<Num> indicator, Number threshold); UnderIndicatorRule(Indicator<Num> indicator, Num threshold); UnderIndicatorRule(Indicator<Num> first, Indicator<Num> second); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); } | @Test public void isSatisfied() { assertTrue(rule.isSatisfied(0)); assertFalse(rule.isSatisfied(1)); assertFalse(rule.isSatisfied(2)); assertFalse(rule.isSatisfied(3)); assertTrue(rule.isSatisfied(4)); assertFalse(rule.isSatisfied(5)); assertFalse(rule.isSatisfied(6)); assertFalse(rule.isSatisfied(7)); } |
PeriodicalGrowthRateIndicator extends CachedIndicator<Num> { public Num getTotalReturn() { Num totalProduct = one; int completeTimeFrames = (getBarSeries().getBarCount() / barCount); for (int i = 1; i <= completeTimeFrames; i++) { int index = i * barCount; Num currentReturn = getValue(index); if (currentReturn != NaN) { currentReturn = currentReturn.plus(one); totalProduct = totalProduct.multipliedBy(currentReturn); } } return totalProduct.pow(one.dividedBy(numOf(completeTimeFrames))); } PeriodicalGrowthRateIndicator(Indicator<Num> indicator, int barCount); Num getTotalReturn(); } | @Test public void testGetTotalReturn() { PeriodicalGrowthRateIndicator gri = new PeriodicalGrowthRateIndicator(this.closePrice, 5); Num result = gri.getTotalReturn(); assertNumEquals(0.9564, result); } |
LowestValueIndicator extends CachedIndicator<Num> { @Override public String toString() { return getClass().getSimpleName() + " barCount: " + barCount; } LowestValueIndicator(Indicator<Num> indicator, int barCount); @Override String toString(); } | @Test public void onlyNaNValues() { BaseBarSeries series = new BaseBarSeries("NaN test"); for (long i = 0; i <= 10000; i++) { series.addBar(ZonedDateTime.now().plusDays(i), NaN, NaN, NaN, NaN, NaN); } LowestValueIndicator lowestValue = new LowestValueIndicator(new ClosePriceIndicator(series), 5); for (int i = series.getBeginIndex(); i <= series.getEndIndex(); i++) { assertEquals(NaN.toString(), lowestValue.getValue(i).toString()); } }
@Test public void naNValuesInIntervall() { BaseBarSeries series = new BaseBarSeries("NaN test"); for (long i = 0; i <= 10; i++) { series.addBar(ZonedDateTime.now().plusDays(i), NaN, NaN, NaN, NaN, NaN); } LowestValueIndicator lowestValue = new LowestValueIndicator(new ClosePriceIndicator(series), 2); for (int i = series.getBeginIndex(); i <= series.getEndIndex(); i++) { if (i % 2 != 0) { assertEquals(series.getBar(i - 1).getClosePrice().toString(), lowestValue.getValue(i).toString()); } else assertEquals(series.getBar(Math.max(0, i - 1)).getClosePrice().toString(), lowestValue.getValue(i).toString()); } } |
HighestValueIndicator extends CachedIndicator<Num> { @Override public String toString() { return getClass().getSimpleName() + " barCount: " + barCount; } HighestValueIndicator(Indicator<Num> indicator, int barCount); @Override String toString(); } | @Test public void onlyNaNValues() { BaseBarSeries series = new BaseBarSeries("NaN test"); for (long i = 0; i <= 10000; i++) { series.addBar(ZonedDateTime.now().plusDays(i), NaN, NaN, NaN, NaN, NaN); } HighestValueIndicator highestValue = new HighestValueIndicator(new ClosePriceIndicator(series), 5); for (int i = series.getBeginIndex(); i <= series.getEndIndex(); i++) { assertEquals(NaN.toString(), highestValue.getValue(i).toString()); } }
@Test public void naNValuesInIntervall() { BaseBarSeries series = new BaseBarSeries("NaN test"); for (long i = 0; i <= 10; i++) { Num closePrice = i % 2 == 0 ? series.numOf(i) : NaN; series.addBar(ZonedDateTime.now().plusDays(i), NaN, NaN, NaN, closePrice, NaN); } HighestValueIndicator highestValue = new HighestValueIndicator(new ClosePriceIndicator(series), 2); for (int i = series.getBeginIndex(); i <= series.getEndIndex(); i++) { if (i % 2 != 0) assertEquals(series.getBar(i - 1).getClosePrice().toString(), highestValue.getValue(i).toString()); else assertEquals(series.getBar(i).getClosePrice().toString(), highestValue.getValue(i).toString()); } } |
ConstantIndicator extends AbstractIndicator<T> { public ConstantIndicator(BarSeries series, T t) { super(series); this.value = t; } ConstantIndicator(BarSeries series, T t); @Override T getValue(int index); @Override String toString(); } | @Test public void constantIndicator() { assertNumEquals("30.33", constantIndicator.getValue(0)); assertNumEquals("30.33", constantIndicator.getValue(1)); assertNumEquals("30.33", constantIndicator.getValue(10)); assertNumEquals("30.33", constantIndicator.getValue(30)); } |
FixedIndicator extends AbstractIndicator<T> { @Override public T getValue(int index) { return values.get(index); } @SafeVarargs FixedIndicator(BarSeries series, T... values); void addValue(T value); @Override T getValue(int index); } | @Test public void getValueOnFixedDecimalIndicator() { BarSeries series = new BaseBarSeries(); FixedDecimalIndicator fixedDecimalIndicator = new FixedDecimalIndicator(series, 13.37, 42, -17); assertNumEquals(13.37, fixedDecimalIndicator.getValue(0)); assertNumEquals(42, fixedDecimalIndicator.getValue(1)); assertNumEquals(-17, fixedDecimalIndicator.getValue(2)); fixedDecimalIndicator = new FixedDecimalIndicator(series, "3.0", "-123.456", "0.0"); assertNumEquals("3.0", fixedDecimalIndicator.getValue(0)); assertNumEquals("-123.456", fixedDecimalIndicator.getValue(1)); assertNumEquals("0.0", fixedDecimalIndicator.getValue(2)); }
@Test public void getValueOnFixedBooleanIndicator() { BarSeries series = new BaseBarSeries(); FixedBooleanIndicator fixedBooleanIndicator = new FixedBooleanIndicator(series, false, false, true, false, true); Assert.assertFalse(fixedBooleanIndicator.getValue(0)); Assert.assertFalse(fixedBooleanIndicator.getValue(1)); Assert.assertTrue(fixedBooleanIndicator.getValue(2)); Assert.assertFalse(fixedBooleanIndicator.getValue(3)); Assert.assertTrue(fixedBooleanIndicator.getValue(4)); } |
InPipeRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { final boolean satisfied = ref.getValue(index).isLessThanOrEqual(upper.getValue(index)) && ref.getValue(index).isGreaterThanOrEqual(lower.getValue(index)); traceIsSatisfied(index, satisfied); return satisfied; } InPipeRule(Indicator<Num> ref, Number upper, Number lower); InPipeRule(Indicator<Num> ref, Num upper, Num lower); InPipeRule(Indicator<Num> ref, Indicator<Num> upper, Indicator<Num> lower); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); } | @Test public void isSatisfied() { assertTrue(rule.isSatisfied(0)); assertTrue(rule.isSatisfied(1)); assertTrue(rule.isSatisfied(2)); assertFalse(rule.isSatisfied(3)); assertFalse(rule.isSatisfied(4)); assertTrue(rule.isSatisfied(5)); assertTrue(rule.isSatisfied(6)); assertTrue(rule.isSatisfied(7)); assertFalse(rule.isSatisfied(8)); assertFalse(rule.isSatisfied(9)); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.