docs: def extrema(self, t0, t1 = None, partition = 2400.0):
  		"""
  		A generator for high and low tides.
  		Arguments:
  		t0 -- time after which extrema are sought
  		t1 -- optional time before which extrema are sought (if not given, the generator is infinite)
  		partition -- number of hours for which we consider the node factors to be constant (default: 2400.0)
  		"""
  		if t1:
  			#yield from in python 3.4
  			for e in takewhile(lambda t: t[0] < t1, self.extrema(t0)):
  				yield e
  		else:
  			#We assume that extrema are separated by at least delta hours
  			delta = np.amin([
  				90.0 / c.speed(astro(t0)) for c in self.model['constituent']
  				if not c.speed(astro(t0)) == 0
  			])
  			#We search for stationary points from offset hours before t0 to
  			#ensure we find any which might occur very soon after t0.
  			offset = 24.0
  			partitions = (
  				Tide._times(t0, i*partition) for i in count()), (Tide._times(t0, i*partition) for i in count(1)
  			)
  
  			#We'll overestimate to be on the safe side;
  			#values outside (start,end) won't get yielded.
  			interval_count = int(np.ceil((partition + offset) / delta)) + 1
  			amplitude = self.model['amplitude'][:, np.newaxis]
  			phase     = d2r*self.model['phase'][:, np.newaxis]
  
  			for start, end in izip(*partitions):
  				speed, [u], [f], V0 = self.prepare(start, Tide._times(start, 0.5*partition))
  				#These derivatives don't include the time dependence of u or f,
  				#but these change slowly.
  				def d(t):
  					return np.sum(-speed*amplitude*f*np.sin(speed*t + (V0 + u) - phase), axis=0)
  				def d2(t):
  					return np.sum(-speed**2.0 * amplitude*f*np.cos(speed*t + (V0 + u) - phase), axis=0)
  				#We'll overestimate to be on the safe side;
  				#values outside (start,end) won't get yielded.
  				intervals = (
  					delta * i -offset for i in range(interval_count)), (delta*(i+1) - offset for i in range(interval_count)
  				)
  				for a, b in izip(*intervals):
  					if d(a)*d(b) < 0:
  						extrema = fsolve(d, (a + b) / 2.0, fprime = d2)[0]
  						time = Tide._times(start, extrema)
  						[height] = self.at([time])
  						hilo = 'H' if d2(extrema) < 0 else 'L'
  						if start < time < end:
  							yield (time, height, hilo)