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

Work on aggregation type for evo graphs

Browse Source
feature/top10
Laurent 7 years ago
parent 8bbc35ba9a
commit 7447305caf
3 changed files with 310 additions and 197 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. 70
      app/src/main/java/net/pokeranalytics/android/calculus/Calculator.kt
  2. 117
      app/src/main/java/net/pokeranalytics/android/ui/fragment/GraphFragment.kt
  3. 42
      app/src/main/java/net/pokeranalytics/android/ui/fragment/StatsFragment.kt

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

@ -7,7 +7,6 @@ import net.pokeranalytics.android.model.comparison.combined
import net.pokeranalytics.android.model.filter.QueryCondition
import net.pokeranalytics.android.model.filter.name
import net.pokeranalytics.android.model.realm.ComputableResult
import net.pokeranalytics.android.model.realm.Filter
import net.pokeranalytics.android.model.realm.SessionSet
import timber.log.Timber
import java.util.*
@ -20,7 +19,11 @@ class Calculator {
/**
* The options used for calculations or display
*/
class Options {
class Options(
display: Display = Display.TABLE,
evolutionValues: EvolutionValues = EvolutionValues.NONE,
stats: List<Stat> = listOf()
) {
/**
* The way the stats are going to be displayed
@ -42,9 +45,9 @@ class Calculator {
TIMED
}
var display: Display = Display.TABLE
var evolutionValues: EvolutionValues = EvolutionValues.NONE
var displayedStats: List<Stat> = listOf()
var display: Display = display
var evolutionValues: EvolutionValues = evolutionValues
var displayedStats: List<Stat> = stats
/**
* This function determines whether the standard deviation should be computed
@ -64,7 +67,36 @@ class Calculator {
companion object {
fun computeStatsWithComparators(realm: Realm, comparators: List<Comparator> = listOf(), conditions: List<QueryCondition> = listOf(), options: Options): Report {
fun computeStatsWithEvolutionByAggregationType(
realm: Realm,
group: ComputableGroup,
aggregationType: AggregationType
): Report {
val options = Options(evolutionValues = Options.EvolutionValues.STANDARD)
if (aggregationType == AggregationType.DURATION) {
options.evolutionValues = Options.EvolutionValues.TIMED
}
return when (aggregationType) {
AggregationType.SESSION, AggregationType.DURATION -> this.computeGroups(realm, listOf(group), options)
AggregationType.MONTH -> {
val comparators: List<Comparator> = listOf(Comparator.YEAR, Comparator.MONTH_OF_YEAR)
this.computeStatsWithComparators(realm, comparators, group.conditions, options)
}
AggregationType.YEAR -> {
val comparators: List<Comparator> = listOf(Comparator.YEAR)
this.computeStatsWithComparators(realm, comparators, group.conditions, options)
}
}
}
fun computeStatsWithComparators(
realm: Realm,
comparators: List<Comparator> = listOf(),
conditions: List<QueryCondition> = listOf(),
options: Options
): Report {
val computableGroups: MutableList<ComputableGroup> = mutableListOf()
comparators.combined().forEach { comparatorConditions ->
@ -86,18 +118,6 @@ class Calculator {
return this.computeGroups(realm, computableGroups, options)
}
fun computeStatsWithFilters(realm: Realm, filters: List<Filter>, options: Options): Report {
val computableGroups: MutableList<ComputableGroup> = mutableListOf()
filters.forEach { filter ->
val group = ComputableGroup(filter.name, filter.filterConditions.map { it.queryCondition })
computableGroups.add(group)
}
return Calculator.computeGroups(realm, computableGroups, options)
}
/**
* Computes all stats for list of Session sessionGroup
*/
@ -257,7 +277,12 @@ class Calculator {
Options.EvolutionValues.TIMED -> {
results.addEvolutionValue(tSum, tHourlyDuration, NETRESULT, sessionSet)
results.addEvolutionValue(tHourlyRate, tHourlyDuration, HOURLY_RATE, sessionSet)
results.addEvolutionValue(tIndex.toDouble(), tHourlyDuration, NUMBER_OF_SETS, sessionSet)
results.addEvolutionValue(
tIndex.toDouble(),
tHourlyDuration,
NUMBER_OF_SETS,
sessionSet
)
results.addEvolutionValue(
sessionSet.netDuration.toDouble(),
tHourlyDuration,
@ -273,7 +298,12 @@ class Calculator {
results.addEvolutionValue(tHourlyRateBB, tHourlyDuration, HOURLY_RATE_BB, sessionSet)
Stat.netBBPer100Hands(gBBSum, gTotalHands)?.let { netBB100 ->
results.addEvolutionValue(netBB100, tHourlyDuration, NET_BB_PER_100_HANDS, sessionSet)
results.addEvolutionValue(
netBB100,
tHourlyDuration,
NET_BB_PER_100_HANDS,
sessionSet
)
}
}
}

117
app/src/main/java/net/pokeranalytics/android/ui/fragment/GraphFragment.kt
Unescape View File

@ -13,7 +13,9 @@ import com.github.mikephil.charting.highlight.Highlight
import com.github.mikephil.charting.listener.OnChartValueSelectedListener
import com.google.android.material.chip.Chip
import com.google.android.material.chip.ChipGroup
import io.realm.Realm
import kotlinx.android.synthetic.main.fragment_evograph.*
import kotlinx.coroutines.*
import net.pokeranalytics.android.R
import net.pokeranalytics.android.calculus.*
import net.pokeranalytics.android.ui.activity.components.PokerAnalyticsActivity
@ -23,25 +25,32 @@ import net.pokeranalytics.android.ui.fragment.components.PokerAnalyticsFragment
import net.pokeranalytics.android.ui.graph.PALineDataSet
import net.pokeranalytics.android.ui.graph.setStyle
import net.pokeranalytics.android.ui.view.LegendView
import timber.log.Timber
import java.text.DateFormat
import java.util.*
import kotlin.coroutines.CoroutineContext
class GraphParameters(var stat: Stat, var report: Report) {
}
class GraphFragment : PokerAnalyticsFragment(), OnChartValueSelectedListener {
class GraphFragment : PokerAnalyticsFragment(), OnChartValueSelectedListener, CoroutineScope {
private lateinit var parentActivity: PokerAnalyticsActivity
private var stat: Stat = Stat.NETRESULT
private var reports: Map<AggregationType, Report> = hashMapOf()
private var entries: List<Entry> = ArrayList()
private var reports: MutableMap<AggregationType, Report> = hashMapOf()
private var selectedReport: Report? = null
lateinit var legendView: LegendView
lateinit var chartView: BarLineChartBase<*>
private var aggregationTypes: List<AggregationType> = listOf()
override val coroutineContext: CoroutineContext
get() = Dispatchers.Main
companion object {
}
@ -50,10 +59,8 @@ class GraphFragment : PokerAnalyticsFragment(), OnChartValueSelectedListener {
this.stat = stat
this.aggregationTypes = stat.aggregationTypes
// this.report = report
report.results.firstOrNull()?.defaultStatEntries(stat)?.let {
this.entries = it
}
this.reports[this.aggregationTypes.first()] = report
this.selectedReport = report
}
@ -76,9 +83,78 @@ class GraphFragment : PokerAnalyticsFragment(), OnChartValueSelectedListener {
this.legendView = LegendView(requireContext())
this.legendContainer.addView(this.legendView)
this.legendView.prepareWithStat(this.stat, this.entries.size)
val dataSet = PALineDataSet(this.entries, this.stat.name, requireContext())
this.selectedReport?.let {
this.loadGraph(it)
}
this.aggregationTypes.forEach { type ->
val chip = Chip(requireContext())
chip.id = type.ordinal
chip.text = requireContext().getString(type.resId)
chip.chipStartPadding = 8f.px
chip.chipEndPadding = 8f.px
this.chipGroup.addView(chip)
}
this.chipGroup.check(this.stat.aggregationTypes.first().ordinal)
this.chipGroup.setOnCheckedChangeListener(object : ChipGroupExtension.SingleSelectionOnCheckedListener() {
override fun onCheckedChanged(group: ChipGroup, checkedId: Int) {
super.onCheckedChanged(group, checkedId)
val aggregationType = aggregationTypes[checkedId]
reports[aggregationType]?.let {
loadGraph(it)
} ?: run {
}
}
})
}
private fun launchStatComputation() {
GlobalScope.launch(coroutineContext) {
var r: Report? = null
val test = GlobalScope.async {
val s = Date()
Timber.d(">>> start...")
val realm = Realm.getDefaultInstance()
val aggregationType = stat.aggregationTypes.first()
// r = Calculator.computeStatsWithEvolutionByAggregationType(realm, computableGroup, aggregationType)
realm.close()
val e = Date()
val duration = (e.time - s.time) / 1000.0
Timber.d(">>> ended in $duration seconds")
}
test.await()
if (!isDetached) {
r?.let {
loadGraph(it)
}
}
}
}
fun loadGraph(report: Report) {
report.results.firstOrNull()?.defaultStatEntries(stat)?.let { entries ->
this.legendView.prepareWithStat(this.stat, entries.size)
val dataSet = PALineDataSet(entries, this.stat.name, requireContext())
val colors = arrayOf(R.color.green_light).toIntArray()
dataSet.setColors(colors, context)
dataSet.setDrawCircles(false)
@ -101,26 +177,8 @@ class GraphFragment : PokerAnalyticsFragment(), OnChartValueSelectedListener {
this.chartView.setStyle(false, requireContext())
this.chartView.setOnChartValueSelectedListener(this)
this.chartView.highlightValue((this.entries.size - 1).toFloat(), 0)
this.aggregationTypes.forEach { type ->
val chip = Chip(requireContext())
chip.id = type.ordinal
chip.text = requireContext().getString(type.resId)
chip.chipStartPadding = 8f.px
chip.chipEndPadding = 8f.px
this.chipGroup.addView(chip)
}
this.chipGroup.check(this.stat.aggregationTypes.first().ordinal)
this.chipGroup.setOnCheckedChangeListener(object : ChipGroupExtension.SingleSelectionOnCheckedListener() {
override fun onCheckedChanged(group: ChipGroup, checkedId: Int) {
super.onCheckedChanged(group, checkedId)
val aggregationType = aggregationTypes[checkedId]
// toast("Show: ${this.aggregationTypes[group.getChildAt(checkedId).id].name}")
this.chartView.highlightValue((entries.size - 1).toFloat(), 0)
}
})
}
@ -133,7 +191,6 @@ class GraphFragment : PokerAnalyticsFragment(), OnChartValueSelectedListener {
override fun onValueSelected(e: Entry?, h: Highlight?) {
e?.let { entry ->
h?.let { highlight ->
val identifier = entry.data as ObjectIdentifier
val item = getRealm().where(identifier.clazz).equalTo("id", identifier.id).findAll().firstOrNull()
@ -145,7 +202,7 @@ class GraphFragment : PokerAnalyticsFragment(), OnChartValueSelectedListener {
this.legendView.setItemData(this.stat, formattedDate, entryValue, totalStatValue)
}
}
}
}

42
app/src/main/java/net/pokeranalytics/android/ui/fragment/StatsFragment.kt
Unescape View File

@ -163,16 +163,38 @@ class StatsFragment : SessionObserverFragment(), StaticRowRepresentableDataSourc
private fun createSessionGroupsAndStartCompute(realm: Realm): Report {
val allStats: List<Stat> = listOf(Stat.NETRESULT, Stat.HOURLY_RATE, Stat.AVERAGE, Stat.NUMBER_OF_SETS, Stat.AVERAGE_DURATION, Stat.DURATION)
val allStats: List<Stat> = listOf(
Stat.NETRESULT,
Stat.HOURLY_RATE,
Stat.AVERAGE,
Stat.NUMBER_OF_SETS,
Stat.AVERAGE_DURATION,
Stat.DURATION
)
val allSessionGroup = ComputableGroup(stringAll, listOf(), allStats)
val cgStats: List<Stat> = listOf(Stat.NETRESULT, Stat.HOURLY_RATE, Stat.NET_BB_PER_100_HANDS, Stat.HOURLY_RATE_BB, Stat.AVERAGE, Stat.STANDARD_DEVIATION_HOURLY, Stat.WIN_RATIO, Stat.NUMBER_OF_GAMES, Stat.AVERAGE_BUYIN)
val cgStats: List<Stat> = listOf(
Stat.NETRESULT,
Stat.HOURLY_RATE,
Stat.NET_BB_PER_100_HANDS,
Stat.HOURLY_RATE_BB,
Stat.AVERAGE,
Stat.STANDARD_DEVIATION_HOURLY,
Stat.WIN_RATIO,
Stat.NUMBER_OF_GAMES,
Stat.AVERAGE_BUYIN
)
val cgSessionGroup = ComputableGroup(stringCashGame, listOf(QueryCondition.CASH), cgStats)
val tStats: List<Stat> = listOf(Stat.NETRESULT, Stat.HOURLY_RATE, Stat.ROI, Stat.WIN_RATIO, Stat.NUMBER_OF_GAMES, Stat.AVERAGE_BUYIN)
val tStats: List<Stat> =
listOf(Stat.NETRESULT, Stat.HOURLY_RATE, Stat.ROI, Stat.WIN_RATIO, Stat.NUMBER_OF_GAMES, Stat.AVERAGE_BUYIN)
val tSessionGroup = ComputableGroup(stringTournament, listOf(QueryCondition.TOURNAMENT), tStats)
Timber.d(">>>>> Start computations...")
return Calculator.computeGroups(realm, listOf(allSessionGroup, cgSessionGroup, tSessionGroup), Calculator.Options())
return Calculator.computeGroups(
realm,
listOf(allSessionGroup, cgSessionGroup, tSessionGroup),
Calculator.Options()
)
}
@ -223,10 +245,14 @@ class StatsFragment : SessionObserverFragment(), StaticRowRepresentableDataSourc
Timber.d(">>> start...")
val realm = Realm.getDefaultInstance()
val options = Calculator.Options()
options.evolutionValues = Calculator.Options.EvolutionValues.STANDARD
options.displayedStats = listOf(stat)
report = Calculator.computeGroups(realm, listOf(computableGroup), options)
// val options = Calculator.Options()
// options.evolutionValues = Calculator.Options.EvolutionValues.STANDARD
// options.displayedStats = listOf(stat)
val aggregationType = stat.aggregationTypes.first()
report = Calculator.computeStatsWithEvolutionByAggregationType(realm, computableGroup, aggregationType)
// report = Calculator.computeGroups(realm, listOf(computableGroup), options)
realm.close()
val e = Date()

Write Preview
Loading…
Cancel
Save