staxriver
/
poker-analytics
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'dev' of gitlab.com:stax-river/poker-analytics into dev

Browse Source
feature/top10
Razmig Sarkissian 7 years ago
parent 02c73ba487 7afea99f58
commit 9c5dad9cf6
5 changed files with 112 additions and 40 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 6
      app/src/androidTest/java/net/pokeranalytics/android/performanceTests/PerfsInstrumentedUnitTest.kt
  2. 51
      app/src/androidTest/java/net/pokeranalytics/android/unitTests/StatsInstrumentedUnitTest.kt
  3. 10
      app/src/main/java/net/pokeranalytics/android/calculus/Calculator.kt
  4. 4
      app/src/main/java/net/pokeranalytics/android/calculus/Report.kt
  5. 81
      app/src/main/java/net/pokeranalytics/android/ui/fragment/CalendarFragment.kt

6
app/src/androidTest/java/net/pokeranalytics/android/performanceTests/PerfsInstrumentedUnitTest.kt
Unescape View File

@ -3,11 +3,11 @@ package net.pokeranalytics.android.performanceTests
import android.content.Context
import androidx.test.core.app.ApplicationProvider
import androidx.test.ext.junit.runners.AndroidJUnit4
import net.pokeranalytics.android.components.RealmInstrumentedUnitTest
import net.pokeranalytics.android.calculus.Calculator
import net.pokeranalytics.android.calculus.ComputableGroup
import net.pokeranalytics.android.calculus.ComputedResults
import net.pokeranalytics.android.calculus.Stat
import net.pokeranalytics.android.components.RealmInstrumentedUnitTest
import net.pokeranalytics.android.model.realm.ComputableResult
import net.pokeranalytics.android.model.realm.Session
import net.pokeranalytics.android.model.realm.SessionSet
@ -54,12 +54,12 @@ class PerfsInstrumentedUnitTest : RealmInstrumentedUnitTest() {
Timber.d("sets: ${sets.size}")
val stats: List<Stat> = listOf(Stat.NETRESULT, Stat.AVERAGE)
val group = ComputableGroup("test", computableResults, sets, stats)
val group = ComputableGroup("test", listOf(), stats)
val options = Calculator.Options()
options.displayedStats = listOf(Stat.STANDARD_DEVIATION_BB_PER_100_HANDS, Stat.STANDARD_DEVIATION)
val results: ComputedResults = Calculator.compute(group, options)
val results: ComputedResults = Calculator.compute(realm, group, options)
Timber.d("*** ended in ${System.currentTimeMillis() - start} milliseconds")
val sum = results.computedStat(Stat.NETRESULT)

51
app/src/androidTest/java/net/pokeranalytics/android/unitTests/StatsInstrumentedUnitTest.kt
Unescape View File

@ -120,14 +120,13 @@ class StatsInstrumentedUnitTest : RealmInstrumentedUnitTest() {
println(">>>>>> rated net = ${it.ratedNet} ")
}
val sets = realm.where(SessionSet::class.java).findAll()
val stats: List<Stat> = listOf(Stat.NETRESULT, Stat.AVERAGE)
val group = ComputableGroup("test", computableResults, sets, stats)
val group = ComputableGroup("test", listOf(), stats)
val options = Calculator.Options()
options.displayedStats = listOf(Stat.STANDARD_DEVIATION_BB_PER_100_HANDS, Stat.STANDARD_DEVIATION)
val results: ComputedResults = Calculator.compute(group, options)
val results: ComputedResults = Calculator.compute(realm, group, options)
val delta = 0.01
val sum = results.computedStat(Stat.NETRESULT)
@ -263,15 +262,13 @@ class StatsInstrumentedUnitTest : RealmInstrumentedUnitTest() {
}
val computableResults = realm.where(ComputableResult::class.java).findAll()
val sets = realm.where(SessionSet::class.java).findAll()
val stats: List<Stat> = listOf(Stat.NETRESULT, Stat.AVERAGE)
val group = ComputableGroup("test", computableResults, sets, stats)
val group = ComputableGroup("test", listOf(), stats)
val options = Calculator.Options()
options.displayedStats = listOf(Stat.STANDARD_DEVIATION_BB_PER_100_HANDS, Stat.STANDARD_DEVIATION)
val results: ComputedResults = Calculator.compute(group, options)
val results: ComputedResults = Calculator.compute(realm, group, options)
val delta = 0.01
val duration = results.computedStat(Stat.DURATION)
@ -332,15 +329,13 @@ class StatsInstrumentedUnitTest : RealmInstrumentedUnitTest() {
realm.commitTransaction()
val computableResults = realm.where(ComputableResult::class.java).findAll()
val sets = realm.where(SessionSet::class.java).findAll()
val stats: List<Stat> = listOf(Stat.NETRESULT, Stat.AVERAGE)
val group = ComputableGroup("test", computableResults, sets, stats)
val group = ComputableGroup("test", listOf(), stats)
val options = Calculator.Options()
options.displayedStats = listOf(Stat.STANDARD_DEVIATION_BB_PER_100_HANDS, Stat.STANDARD_DEVIATION)
val results: ComputedResults = Calculator.compute(group, options)
val results: ComputedResults = Calculator.compute(realm, group, options)
val delta = 0.01
val duration = results.computedStat(Stat.DURATION)
@ -417,15 +412,13 @@ class StatsInstrumentedUnitTest : RealmInstrumentedUnitTest() {
realm.commitTransaction()
val computableResults = realm.where(ComputableResult::class.java).findAll()
val sets = realm.where(SessionSet::class.java).findAll()
val stats: List<Stat> = listOf(Stat.NETRESULT, Stat.AVERAGE)
val group = ComputableGroup("test", computableResults, sets, stats)
val group = ComputableGroup("test", listOf(), stats)
val options = Calculator.Options()
options.displayedStats = listOf(Stat.STANDARD_DEVIATION_BB_PER_100_HANDS, Stat.STANDARD_DEVIATION)
val results: ComputedResults = Calculator.compute(group, options)
val results: ComputedResults = Calculator.compute(realm, group, options)
val delta = 0.01
val duration = results.computedStat(Stat.DURATION)
@ -439,12 +432,10 @@ class StatsInstrumentedUnitTest : RealmInstrumentedUnitTest() {
s1.deleteFromRealm()
}
val computableResults2 = realm.where(ComputableResult::class.java).findAll()
val sets2 = realm.where(SessionSet::class.java).findAll()
val stats2: List<Stat> = listOf(Stat.NETRESULT, Stat.AVERAGE)
val group2 = ComputableGroup("test", computableResults2, sets2, stats2)
val group2 = ComputableGroup("test", listOf(), stats2)
val results2: ComputedResults = Calculator.compute(group2, options)
val results2: ComputedResults = Calculator.compute(realm, group2, options)
val duration2 = results2.computedStat(Stat.DURATION)
if (duration2 != null) {
@ -566,15 +557,13 @@ class StatsInstrumentedUnitTest : RealmInstrumentedUnitTest() {
s1.endDate = null
}
val computableResults = realm.where(ComputableResult::class.java).findAll()
val sets = realm.where(SessionSet::class.java).findAll()
val stats: List<Stat> = listOf(Stat.NETRESULT, Stat.AVERAGE)
val group = ComputableGroup("test", computableResults, sets, stats)
val group = ComputableGroup("test", listOf(), stats)
val options = Calculator.Options()
// options.displayedStats = listOf(Stat.STANDARD_DEVIATION_BB_PER_100_HANDS, Stat.STANDARD_DEVIATION)
val results: ComputedResults = Calculator.compute(group, options)
val results: ComputedResults = Calculator.compute(realm, group, options)
val delta = 0.01
val duration = results.computedStat(Stat.DURATION)
@ -623,9 +612,9 @@ class StatsInstrumentedUnitTest : RealmInstrumentedUnitTest() {
val computableResults = realm.where(ComputableResult::class.java).findAll()
val sets = realm.where(SessionSet::class.java).findAll()
val stats: List<Stat> = listOf(Stat.NETRESULT)
val group = ComputableGroup("test", computableResults, sets, stats)
val group = ComputableGroup("test", listOf(), stats)
val options = Calculator.Options()
val results: ComputedResults = Calculator.compute(group, options)
val results: ComputedResults = Calculator.compute(realm, group, options)
val netResult = results.computedStat(Stat.NETRESULT)
Assert.assertEquals(250.0, netResult?.value)
@ -658,12 +647,10 @@ class StatsInstrumentedUnitTest : RealmInstrumentedUnitTest() {
}
val computableResults = realm.where(ComputableResult::class.java).findAll()
val sets = realm.where(SessionSet::class.java).findAll()
val stats: List<Stat> = listOf(Stat.NETRESULT)
val group = ComputableGroup("test", computableResults, sets, stats)
val group = ComputableGroup("test", listOf(), stats)
val options = Calculator.Options()
val results: ComputedResults = Calculator.compute(group, options)
val results: ComputedResults = Calculator.compute(realm, group, options)
val netResult = results.computedStat(Stat.NETRESULT)
Assert.assertEquals(250.0, netResult?.value)
@ -679,10 +666,8 @@ class StatsInstrumentedUnitTest : RealmInstrumentedUnitTest() {
}
}
val updatedComputableResults = realm.where(ComputableResult::class.java).findAll()
val updatedSets = realm.where(SessionSet::class.java).findAll()
val updatedGroup = ComputableGroup("test", updatedComputableResults, updatedSets, stats)
val updatedResults: ComputedResults = Calculator.compute(updatedGroup, options)
val updatedGroup = ComputableGroup("test", listOf(), stats)
val updatedResults: ComputedResults = Calculator.compute(realm, updatedGroup, options)
val updatedNetResult = updatedResults.computedStat(Stat.NETRESULT)
Assert.assertEquals(650.0, updatedNetResult?.value)

10
app/src/main/java/net/pokeranalytics/android/calculus/Calculator.kt
Unescape View File

@ -73,11 +73,17 @@ class Calculator {
allConditions.addAll(conditions)
allConditions.addAll(comparatorConditions)
val group = ComputableGroup(allConditions.name(), conditions)
val group = ComputableGroup(allConditions.name(), allConditions)
computableGroups.add(group)
}
return Calculator.computeGroups(realm, computableGroups, options)
if (computableGroups.size == 0) {
val group = ComputableGroup(conditions.name(), conditions)
computableGroups.add(group)
}
return this.computeGroups(realm, computableGroups, options)
}
fun computeStatsWithFilters(realm: Realm, filters: List<Filter>, options: Options): Report {

4
app/src/main/java/net/pokeranalytics/android/calculus/Report.kt
Unescape View File

@ -136,6 +136,8 @@ class ComputableGroup(name: String, conditions: List<QueryCondition>, stats: Lis
this._sessionSets = null
}
val isEmpty: Boolean = this._computables?.isEmpty() ?: true
}
class ComputedResults(group: ComputableGroup) {
@ -258,6 +260,8 @@ class ComputedResults(group: ComputableGroup) {
return entries
}
val isEmpty: Boolean = this.group.comparedComputables?.isEmpty ?: true
}
class Point(val x: Double, val y: Double, val data: Any) {

81
app/src/main/java/net/pokeranalytics/android/ui/fragment/CalendarFragment.kt
Unescape View File

@ -5,14 +5,23 @@ import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.recyclerview.widget.LinearLayoutManager
import io.realm.Realm
import kotlinx.android.synthetic.main.fragment_calendar.*
import kotlinx.android.synthetic.main.fragment_stats.recyclerView
import kotlinx.coroutines.*
import net.pokeranalytics.android.R
import net.pokeranalytics.android.ui.fragment.components.PokerAnalyticsFragment
import net.pokeranalytics.android.calculus.Calculator
import net.pokeranalytics.android.calculus.Report
import net.pokeranalytics.android.calculus.Stat
import net.pokeranalytics.android.model.comparison.Comparator
import net.pokeranalytics.android.model.filter.QueryCondition
import net.pokeranalytics.android.ui.fragment.components.SessionObserverFragment
import net.pokeranalytics.android.ui.view.CalendarTabs
import java.util.*
import kotlin.coroutines.CoroutineContext
class CalendarFragment : PokerAnalyticsFragment() {
class CalendarFragment : SessionObserverFragment(), CoroutineScope {
companion object {
@ -46,8 +55,76 @@ class CalendarFragment : PokerAnalyticsFragment() {
* Init data
*/
private fun initData() {
val comparator = Comparator.MONTH // returns all months
val conditions = comparator.queryConditions
conditions.forEach {
val realm = getRealm()
Calculator.computeStatsWithComparators(realm, conditions = listOf(it), options = Calculator.Options())
}
}
override val coroutineContext: CoroutineContext
get() = Dispatchers.Main
private fun launchStatComputation() {
val comparator = Comparator.MONTH // returns all months
// val conditions = comparator.queryConditions
val conditions = listOf(QueryCondition.CASH, QueryCondition.TOURNAMENT)
conditions.forEach {
val realm = getRealm()
GlobalScope.launch(coroutineContext) {
var r = Report()
val test = GlobalScope.async {
val s = Date()
val realm = Realm.getDefaultInstance()
val report = Calculator.computeStatsWithComparators(realm, conditions = listOf(it), options = Calculator.Options())
report.results.firstOrNull()?.let {
val isEmpty = it.isEmpty
val statValue = it.computedStat(Stat.NETRESULT)?.value
}
// r = createSessionGroupsAndStartCompute(realm)
// report = r
realm.close()
}
test.await()
if (!isDetached) {
// showResults(r)
}
}
}
}
/**
* Init UI
*/

Write Preview
Loading…
Cancel
Save