def __init__(self, rid, created, size, pickup, delivery, transport=None, carry=None, restrictions=None):
"""
Initialization method.
:param rid: Request unique ID.
:type rid: int
:param created: Time in seconds from now since the request was created.
:type created: int
:param size: Request size.
:type size: int
:param pickup: Pickup job.
:type pickup: routevo.job.Job
:param delivery: Delivery job.
:type delivery: routevo.job.Job
"""
assert isinstance(rid, six.integer_types)
assert check(created, (float, six.integer_types))
assert check(size, (float, six.integer_types))
assert isinstance(pickup, Job)
assert isinstance(delivery, Job)
assert check(transport, (TimeWindow, None))
assert check(carry, (TimeWindow, None))
assert check(restrictions, (Restrictions, None))
self.id = rid
self.created = int(created)
self.size = float(size)
self.pickup = pickup.parent(self)
self.delivery = delivery.parent(self)
self.transport = transport
self.carry = carry
self.restrictions = Restrictions() if restrictions is None else restrictions
def __init__(self, longitude, latitude):
"""
Initialization method.
:param longitude: Longitude in degrees.
:type longitude: float
:param latitude: Latitude in degrees
:type latitude: float
"""
assert check(longitude, (float, six.integer_types))
assert check(latitude, (float, six.integer_types))
self.longitude = float(longitude)
self.latitude = float(latitude)
def __init__(self,
jid,
t,
location,
arrival,
waiting,
aid=None,
times=None):
"""
Initialization method.
:param jid: Job unique ID.
:type jid: int
:param t: Type of job: PICKUP or DELIVERY
:type t: str
:param location: Job location.
:type location: routevo.utils.point.Point
:param arrival: Soft restriction on arrival time.
:type arrival: routevo.constraints.soft.tw.TimeWindow | None
:param aid: Location ID. It is used to distinguish, for example,
different floors of the same building, and to group jobs from the same location.
:type aid: int | None
:param times: Realization times of finished phases of job, in seconds from now.
:type times: dict[str, int|float|None] | None
"""
assert isinstance(jid, six.integer_types)
assert isinstance(t, six.string_types) and t in self.ALL
assert isinstance(location, Point)
assert check(arrival, (TimeWindow, None))
assert check(waiting, (float, six.integer_types))
assert check(aid, (six.integer_types, None))
assert check(times, (dict, None))
self.id = jid
self.type = t
self.aid = aid
self.location = location
self.arrival = arrival
self.waiting = float(waiting)
_times = {} if times is None else times
self.begin = _times.get('begin', None)
self.at = _times.get('at', None)
self.end = _times.get('end', None)
self.request = None
self._size = None
def __init__(self, limit):
"""
Initialization method.
:param limit: Constraint limit, eg. vehicle capacity, maximum deliveries etc.
:type limit: float
"""
assert check(limit, (float, six.integer_types))
self.limit = float(limit)
def __init__(self, penalty, limit, margin=0.0):
"""
Initialization method.
:param penalty: Penalty for violating constraint.
:type penalty: routevo.utils.penalty.Penalty
:param limit: Constraint limit, eg. distance, time etc.
:type limit: float
:param margin: Safety margin. Limit + margin = upper limit.
:type margin: float
"""
assert isinstance(penalty, Penalty)
assert check(limit, (float, integer_types))
assert check(margin, (float, integer_types))
self.limit = float(limit)
self.margin = float(margin)
self.cf = penalty
def __init__(self, timeout=None):
"""
Initialization method.
:param timeout: Maximum time in seconds for optimization.
None means to optimize as long, as there is no improvement.
:type timeout: float | int | None
"""
assert check(timeout, (float, six.integer_types, None))
self.timeout = float(timeout)
def __init__(self, lower, expected, upper, penalty):
"""
Initialization method.
:param lower: lower time limit in seconds of arrival
:type lower: float
:param expected: expected time in seconds of arrival
:type expected: float | None
:param upper: upper time limit in seconds of arrival
:type upper: float | None
:param penalty: cost function object
:type penalty: routevo.utils.penalty.Penalty | None
"""
assert check(lower, (float, integer_types))
assert check(expected, (float, integer_types, None))
assert check(upper, (float, integer_types, None))
assert isinstance(penalty, Penalty)
self.lower = float(lower)
self.expected = float(expected)
self.upper = float(upper)
self.penalty = penalty
def __init__(self, kind=None, timeout=None):
"""
Initialization method.
:param kind: Type of distances in matrix.
:type kind: basestring | None
:param timeout: Maximum time in seconds to wait for a computation of distances matrix.
None means to wait as much as necessary.
:type timeout: float | int | None
"""
assert kind is None or kind in self.ALL
assert check(timeout, (float, six.integer_types, None))
self.kind = kind
self.timeout = float(timeout)
def __init__(self, vid, location, speed, amortization, salary, availability=None,
locked=None, restrictions=None, time=0.0, waiting=0.0):
"""
Initialization method.
:param vid: Unique vehicle ID.
:type vid: int
:param location: Current geographical location of vehicle.
:type location: routevo.utils.point.Point
:param speed: Average speed in km/h.
:type speed: float
:param amortization: Amortization cost per kilometer.
:type amortization: float
:param salary: Driver salary cost per hour.
:type salary: float
:param availability: Time window defining when vehicle is operational.
:type availability: routevo.constraints.mixed.availability.Availability | None
:param locked: Number of locked jobs in route.
:type locked: int | None
:param restrictions: Restrictions for vehicle.
:type restrictions: routevo.constraints.restrictions.Restrictions | None
:param time: Location age.
:type time: int
"""
assert isinstance(vid, six.integer_types)
assert isinstance(location, Point)
assert check(time, (float, six.integer_types))
assert check(speed, (float, six.integer_types))
assert check(waiting, (float, six.integer_types))
assert check(amortization, (float, six.integer_types))
assert check(salary, (float, six.integer_types))
assert check(availability, (Availability, None))
assert check(locked, (six.integer_types, None))
assert check(restrictions, (Restrictions, None))
self.id = vid
self.location = location
self.time = float(time)
self.speed = float(speed)
self.waiting = float(waiting)
self.amortization = float(amortization)
self.salary = float(salary)
self.availability = availability
self.locked = 0 if locked is None else int(locked)
self.restrictions = Restrictions() if restrictions is None else restrictions
def __init__(self, routes, unassigned=None):
"""
Initialization method.
:param routes: Routes.
:type routes: list[routevo.route.Route]
:param unassigned: New or unassigned requests to any vehicle.
:type unassigned: list[routevo.request.Request]
"""
assert isinstance(routes, list)
for r in routes:
assert isinstance(r, Route)
assert check(unassigned, (list, None))
if unassigned is not None:
for r in unassigned:
assert isinstance(r, Request)
self.routes = {r.vehicle.id: r for r in routes}
self.unassigned = [] if unassigned is None else unassigned
def __init__(self, attributes=None, filters=None, hard=None, soft=None):
"""
Initialization method.
:param attributes: User defined attributes held by object.
:type attributes: dict
:param filters: Filters constraints.
:type filters: list[routevo.constraints.hard.base.BaseMatchConstraint]
:param hard: List of hard constraints.
:type hard: list[routevo.constraints.hard.base.BaseHardConstraint]
:param soft: List of soft constraints.
:type soft: list[routevo.constraints.soft.base.BaseSoftConstraint]
"""
assert check(attributes, (dict, None))
self._validate(filters, self.FILTERS.values())
self._validate(hard, self.HARD.values())
self._validate(soft, self.SOFT.values())
self.attributes = {} if attributes is None else attributes
self.filters = [] if filters is None else filters
self.hard = [] if hard is None else hard
self.soft = [] if soft is None else soft
