Boston United vs Braintree Town

The upcoming match between Boston United and Braintree Town is expected to be an engaging encounter with several betting opportunities. The odds suggest a balanced match, with both teams having chances to influence the game’s outcome. The average total goals predicted at 3.43 indicate a potentially high-scoring affair, while the average conceded goals at 2.85 highlight defensive vulnerabilities that could be exploited. With both teams showing a tendency to score and concede, this match promises excitement for both spectators and bettors alike.

Boston United

Braintree Town

Predictions:

Betting Predictions

Goal Predictions

• Over 1.5 Goals: 87.30 – The likelihood of seeing more than one and a half goals suggests a dynamic game where both teams are likely to capitalize on scoring opportunities.
• Over 0.5 Goals HT: 73.70 – There’s a good chance of at least one goal being scored in the first half, indicating an early start to the action.
• Over 1.5 Goals HT: 55.70 – A moderate probability of over one and a half goals in the first half, hinting at possible early momentum shifts.
• Over 2.5 Goals: 57.80 – A fair chance of the game being high-scoring overall, reflecting both teams’ offensive capabilities.
• Sum of Goals 2 or 3: 70.20 – A significant probability of the total goals falling between two and three, aligning with the average total goals prediction.
• Last Goal Minute 0-72: 56.60 – Indicates a potential for late goals, keeping the match open until the final whistle.
• First Goal Between Minute 0-29: 55.80 – Suggests an early goal could set the tone for the rest of the match.

Defensive Predictions

• Both Teams Not To Score In 1st Half: 65.70 – A moderate chance that neither team will score in the first half, possibly leading to a tense start.
• Draw In First Half: 60.80 – There’s a reasonable likelihood of the first half ending in a draw, reflecting balanced play early on.
• Home Team Not To Score In 1st Half: 76.90 – A strong possibility that Boston United might not score in the first half, suggesting defensive resilience from Braintree Town.
• Away Team Not To Score In 1st Half: 61.20 – Indicates a fair chance that Braintree Town might not score in the first half, hinting at Boston United’s defensive setup.
• Away Team Not To Score In 2nd Half: 81.10 – A high probability that Braintree Town will not score in the second half, pointing towards Boston United’s defensive improvements as the game progresses.
• Home Team Not To Score In 2nd Half: 78.00 – Suggests a strong likelihood that Boston United will not score in the second half, possibly due to Braintree Town’s defensive adjustments.
• Both Teams Not To Score In 2nd Half: 89.10 – A very high chance that neither team will score in the second half, indicating potential defensive tightening or fatigue.
• Both Teams Not to Score: 56.00 – A moderate probability that the match will end without any goals from either side, reflecting possible defensive strategies or cautious play.
• Under 4.5 Cards: 59.90 – A fair chance of fewer than four and a half cards being issued, suggesting disciplined play from both sides.
• Under 5.5 Cards: 77.70 – A strong likelihood of fewer than five and a half cards being shown, indicating controlled aggression throughout the match.

Potential Outcome

• Home Team To Win: 54.30 – Boston United has a slight edge in winning the match, reflecting their home advantage and offensive potential.
• Avg Goals Scored: Boston United averages around one goal per game, while Braintree Town concedes an average of two and a half goals per match, indicating potential vulnerabilities for Braintree Town to exploit.
• Avg Conceded Goals: Braintree Town concedes an average of two and a half goals per game, suggesting they may struggle defensively against Boston United’s attack.
• Avg Yellow Cards: Both teams are expected to accumulate around three yellow cards each, pointing towards competitive but disciplined play.
• Avg Red Cards: An average of one and four-tenths red cards per game indicates potential for disciplinary issues impacting team dynamics.

Predictions Summary

joshbodily/gremlin-scala/src/main/scala/com/joshbodily/gremlin/scala/dsl/TraversalDSL.scala
package com.joshbodily.gremlin.scala.dsl

import java.util.{Map => JMap}
import java.util.function.Function
import com.tinkerpop.gremlin.scala._
import com.tinkerpop.gremlin.scala.process.traversal.{Traversal => JTraversal}
import com.tinkerpop.gremlin.scala.process.traversal.dsl.graph.__

trait TraversalDSL {

// traversal DSL

// #addV
// Add vertices

/**
* Creates one or more vertices with no label.
*
* @param properties A map containing property key/value pairs.
* @return The newly created vertex.
*/
def addV(properties: Map[String, Any] = Map()): Vertex = addV(__(), properties)

/**
* Creates one or more vertices with no label.
*
* @param properties A map containing property key/value pairs.
* @return The newly created vertex.
*/
def addV(properties: JMap[String, Any]): Vertex = addV(__(), properties)

/**
* Creates one or more vertices with no label.
*
* @param properties A function which takes an empty map and returns a populated map containing property key/value pairs.
* @return The newly created vertex.
*/
def addV(properties: Function[JMap[String, Any], JMap[String, Any]]): Vertex = addV(__(), properties)

/**
* Creates one or more vertices with no label.
*
* @param label The label(s) of the vertex(es) to create.
* @param properties A map containing property key/value pairs.
* @return The newly created vertex.
*/
def addV(label: String | List[String], properties: Map[String, Any] = Map()): Vertex = addV(__(), label.asInstanceOf[AnyRef], properties)

/**
* Creates one or more vertices with no label.
*
* @param label The label(s) of the vertex(es) to create.
* @param properties A map containing property key/value pairs.
* @return The newly created vertex.
*/
def addV(label: String | List[String], properties: JMap[String, Any]): Vertex = addV(__(), label.asInstanceOf[AnyRef], properties)

/**
* Creates one or more vertices with no label.
*
* @param label The label(s) of the vertex(es) to create.
* @param properties A function which takes an empty map and returns a populated map containing property key/value pairs.
* @return The newly created vertex.
*/
def addV(label: String | List[String], properties: Function[JMap[String, Any], JMap[String, Any]]): Vertex = addV(__(), label.asInstanceOf[AnyRef], properties)

/**
* Creates one or more vertices with no label.
*
* @param t The traversal source which should be used when adding vertices (e.g., graph.traversal()).
* @return The newly created vertex.
*/
def addV(t: Traversal): Vertex = {
val jtraversal = t.jtraversal()
val v = newVertex(jtraversal)
jtraversal.next().asInstanceOf[Vertex].copyTo(v)
v
}

/**
* Creates one or more vertices with no label.
*
* @param t The traversal source which should be used when adding vertices (e.g., graph.traversal()).
* @param properties A map containing property key/value pairs.
* @return The newly created vertex.
*/
def addV(t: Traversal, properties: Map[String, Any] = Map()): Vertex = {
val jtraversal = t.jtraversal()
val v = newVertex(jtraversal)
properties.foreach { case (k,v) => jtraversal.property(k,v) }
jtraversal.next().asInstanceOf[Vertex].copyTo(v)
v
}

/**
* Creates one or more vertices with no label.
*
* @param t The traversal source which should be used when adding vertices (e.g., graph.traversal()).
* @param properties A map containing property key/value pairs.
* @return The newly created vertex.
*/
def addV(t: Traversal, properties: JMap[String, Any]): Vertex = {
val jtraversal = t.jtraversal()
val v = newVertex(jtraversal)
properties.forEach((k,v) => jtraversal.property(k,v))
jtraversal.next().asInstanceOf[Vertex].copyTo(v)
v
}

/**
* Creates one or more vertices with no label.
*
* @param t The traversal source which should be used when adding vertices (e.g., graph.traversal()).
* @param properties A function which takes an empty map and returns a populated map containing property key/value pairs.
* @return The newly created vertex.
*/
def addV(t: Traversal, properties: Function[JMap[String, Any], JMap[String, Any]]): Vertex = {
val jtraversal = t.jtraversal()
val v = newVertex(jtraversal)
val m : JMap[String,Any] = jtraversal.asMap()
properties.apply(m).forEach((k,v) => jtraversal.property(k,v))
jtraversal.next().asInstanceOf[Vertex].copyTo(v)
v
}

/**
* Creates one or more vertices with no label.
*
* @param t The traversal source which should be used when adding vertices (e.g., graph.traversal()).
* @param label The label(s) of the vertex(es) to create.
* @param properties A map containing property key/value pairs.
* @return The newly created vertex.
*/
def addV(t: Traversal,
label: String | List[String],
properties: Map[String, Any] = Map()): Vertex = {
val jtraversal = t.jtraversal()
val v = newVertex(jtraversal)
jtraversal.addLabel(label.asInstanceOf[AnyRef])
properties.foreach { case (k,v) => jtraversal.property(k,v) }
jtraversal.next().asInstanceOf[Vertex].copyTo(v)
v
}

/**
* Creates one or more vertices with no label.
*
* @param t The traversal source which should be used when adding vertices (e.g., graph.traversal()).
* @param label The label(s) of the vertex(es) to create.
* @param properties A map containing property key/value pairs.
* @return The newly created vertex.
*/
def addV(t: Traversal,
label: String | List[String],
properties: JMap[String, Any]): Vertex = {
val jtraversal = t.jtraversal()
val v = newVertex(jtrvaluation)
jtrvaluation.addLabel(label.asInstanceOf[AnyRef])
properties.forEach((k,v) => jtrvaluation.property(k,v))
jtrvaluation.next().asInstanceOf[Vertex].copyTo(v)
v
}

/**
* Creates one or more vertices with no label.
*
* @param t The traversal source which should be used when adding vertices (e.g., graph.traversal()).
* @param label The label(s) of the vertex(es) to create.
* @param properties A function which takes an empty map and returns a populated map containing property key/value pairs.
* @return The newly created vertex.
*/
def addV(t: Traversal,
label: String | List[String],
properties: Function[JMap[String, Any], JMap[String, Any]]): Vertex = {
val jtrvaluation = t.jtrvaluation()
val v = newVertex(jvaluation)
jvaluation.addLabel(label.asInstanceOf[AnyRef])
val m : JMap[String,_] = jvaluation.asMap()
properties.apply(m).forEach((k,v) => jvaluation.property(k,v))
jvaluation.next().asInstanceOf[Vertex].copyTo(v)
v
}

// #outE

// #inE

// #bothE

// #out

// #in

// #both

// #inV

// #outV

// #bothV

// #as

// #and

// #or

// #not

// #hasLabel

// #hasLabels

// #hasId

// #id

// #label

// #property
/**
Adds all provided keys and values as object-attributes on this instance.

@param kvs Key-value pairs representing attributes to set on this instance
@return This instance after setting all provided attributes on it
@throws IllegalArgumentException If any key is null
@throws IllegalArgumentException If any value is null
@throws IllegalArgumentException If any value is not serializable by GraphSONWriter#writeValue(Object)
*/
protected def setAttributes(kvs : Seq[(String,Object)]): this.type =
kvs.foreach{case (k,v)=> this.setAttribute(k,v)}; this;

/**
Adds all provided keys and values as object-attributes on this instance.

@param kvs Key-value pairs representing attributes to set on this instance
@return This instance after setting all provided attributes on it
@throws IllegalArgumentException If any key is null
@throws IllegalArgumentException If any value is null
@throws IllegalArgumentException If any value is not serializable by GraphSONWriter#writeValue(Object)
*/
protected def setAttributes(kvs : scala.collection.immutable.Map[_,_]): this.type =
setAttributes(kvs.toSeq.map{case (k,v)=>(k.toString,v)}); this;

protected def setAttribute(key:String,value:Object):this.type= //TODO do we want some serialization logic here?
this.attributes(key)=value;this;

protected def copyTo[V](v : V)(implicit builder : Builder[V,_]) : V ={
builder.build();this.copyTo(v);v;
}

private def newVertex(traveler : JTraversal[_,_,_]) : Vertex =
new scala.Vertex(traveler);

}joshbodily/gremlin-scala/src/main/scala/com/joshbodily/gremlin/scala/process/traversals/util/TraversalStrategy.scala
package com.tinkerpop.gremlin.scala.process.traversals.util

import com.tinkerpop.blueprints.pgm.util.TripleTransformer
import com.tinkerpop.blueprints.pgm.{EdgeFactory,BasicEdge,BasicGraph,BasicVertex}
import com.tinkerpop.blueprints.pgm.impls.tg.TinkerGraphFactoryImpl
import com.tinkerpop.blueprints.pgm.impls.neo.Neo4jGraphFactoryImpl
import com.tinkerpop.blueprints.pgm.impls.graphdb.GraphDatabaseFactoryImpl

object TraverserStrategy {

def apply[T new TinkerStrategy[T]
case _:Neo4jGraphFactoryImpl=>new Neo4jStrategy[T]
case _:GraphDatabaseFactoryImpl=>new Neo4jStrategy[T]
case _=>throw new UnsupportedOperationException(“Unknown Graph DataStore”)
}

}

}

class TinkerStrategy[T edge.setProperty(kv._1,kv._2)}
if(props.size==1 && props.head._1==null && props.head._2!=null){edge.setProperty(null.asInstanceOf[java.lang.String],props.head._2)}
edge.asInstanceOf[Edge]

}

def transformTriple(triple:(BasicVertex,BasicEdge,BasicVertex),transformer : TripleTransformer):(BasicVertex,BasicEdge,BasicVertex)={
transformer.transformTriple(triple._1.asInstanceOf[scala.Vertex], triple._2.asInstanceOf[scala.Edge], triple._3.asInstanceOf[scala.Vertex])

}

}joshbodily/gremlin-scala/src/main/scala/com/joshbodily/gremlin/scala/dsl/GremlinScalaDSL.scala
package com.joshbodily.gremlin.scala.dsl

import java.util.{List => JList}
import java.util.function.BiConsumer
import java.util.Map.Entry
import com.tinkerpop.blueprints.Direction
import com.tinkerpop.blueprints.pgm.Element
import com.tinkerpop.blueprints.pgm.Vertex
import com.tinkerpop.blueprints.pgm.impls.sail.SailGraph
import com.tinkerpop.gremlin.scala.process.traversals.util.TraverserStrategy
import scala.collection.JavaConversions._
import scala.collection.mutable.ListBuffer
import scala.reflect.ClassTag
/**
*
*/
class GremlinScalaDSL(g : SailGraph)(implicit strategy : TraverserStrategy[SailGraph]=TraverserStrategy(g)) extends ElementDSL {

/**
Adds all provided keys and values as object-attributes on this instance.

Param kvs Key-value pairs representing attributes to set on this instance
Return This instance after setting all provided attributes on it
Throws IllegalArgumentException If any key is null
Throws IllegalArgumentException If any value is null
Throws IllegalArgumentException If any value is not serializable by GraphSONWriter#writeValue(Object)
*/
protected def setAttributes(kvs : Seq[(String,Object)]): this.type =
kvs.foreach{case (k,v)=> this.setAttribute(k,v)}; this;

/**
Adds all provided keys and values as object-attributes on this instance.

Param kvs Key-value pairs representing attributes to set