docs: function (params) {
  			var _super = _jp.Segments.AbstractSegment.apply(this, arguments),
  				_calcAngle = function (_x, _y) {
  					return _jg.theta([params.cx, params.cy], [_x, _y]);
  				},
  				_calcAngleForLocation = function (segment, location) {
  					if (segment.anticlockwise) {
  						var sa = segment.startAngle < segment.endAngle ? segment.startAngle + TWO_PI : segment.startAngle,
  							s = Math.abs(sa - segment.endAngle);
  						return sa - (s * location);
  					}
  					else {
  						var ea = segment.endAngle < segment.startAngle ? segment.endAngle + TWO_PI : segment.endAngle,
  							ss = Math.abs(ea - segment.startAngle);
  
  						return segment.startAngle + (ss * location);
  					}
  				},
  				TWO_PI = 2 * Math.PI;
  
  			this.radius = params.r;
  			this.anticlockwise = params.ac;
  			this.type = "Arc";
  
  			if (params.startAngle && params.endAngle) {
  				this.startAngle = params.startAngle;
  				this.endAngle = params.endAngle;
  				this.x1 = params.cx + (this.radius * Math.cos(params.startAngle));
  				this.y1 = params.cy + (this.radius * Math.sin(params.startAngle));
  				this.x2 = params.cx + (this.radius * Math.cos(params.endAngle));
  				this.y2 = params.cy + (this.radius * Math.sin(params.endAngle));
  			}
  			else {
  				this.startAngle = _calcAngle(params.x1, params.y1);
  				this.endAngle = _calcAngle(params.x2, params.y2);
  				this.x1 = params.x1;
  				this.y1 = params.y1;
  				this.x2 = params.x2;
  				this.y2 = params.y2;
  			}
  
  			if (this.endAngle < 0) this.endAngle += TWO_PI;
  			if (this.startAngle < 0) this.startAngle += TWO_PI;
  
  			// segment is used by vml     
  			//this.segment = _jg.quadrant([this.x1, this.y1], [this.x2, this.y2]);
  
  			// we now have startAngle and endAngle as positive numbers, meaning the
  			// absolute difference (|d|) between them is the sweep (s) of this arc, unless the
  			// arc is 'anticlockwise' in which case 's' is given by 2PI - |d|.
  
  			var ea = this.endAngle < this.startAngle ? this.endAngle + TWO_PI : this.endAngle;
  			this.sweep = Math.abs(ea - this.startAngle);
  			if (this.anticlockwise) this.sweep = TWO_PI - this.sweep;
  			var circumference = 2 * Math.PI * this.radius,
  				frac = this.sweep / TWO_PI,
  				length = circumference * frac;
  
  			this.getLength = function () {
  				return length;
  			};
  
  			this.getBounds = function () {
  				return {
  					minX: params.cx - params.r,
  					maxX: params.cx + params.r,
  					minY: params.cy - params.r,
  					maxY: params.cy + params.r
  				};
  			};
  
  			var VERY_SMALL_VALUE = 0.0000000001,
  				gentleRound = function (n) {
  					var f = Math.floor(n), r = Math.ceil(n);
  					if (n - f < VERY_SMALL_VALUE)
  						return f;
  					else if (r - n < VERY_SMALL_VALUE)
  						return r;
  					return n;
  				};
  
  			/**
  			 * returns the point on the segment's path that is 'location' along the length of the path, where 'location' is a decimal from
  			 * 0 to 1 inclusive.
  			 */
  			this.pointOnPath = function (location, absolute) {
  
  				if (location === 0) {
  					return { x: this.x1, y: this.y1, theta: this.startAngle };
  				}
  				else if (location == 1) {
  					return { x: this.x2, y: this.y2, theta: this.endAngle };
  				}
  
  				if (absolute) {
  					location = location / length;
  				}
  
  				var angle = _calcAngleForLocation(this, location),
  					_x = params.cx + (params.r * Math.cos(angle)),
  					_y = params.cy + (params.r * Math.sin(angle));
  
  				return { x: gentleRound(_x), y: gentleRound(_y), theta: angle };
  			};
  
  			/**
  			 * returns the gradient of the segment at the given point.
  			 */
  			this.gradientAtPoint = function (location, absolute) {
  				var p = this.pointOnPath(location, absolute);
  				var m = _jg.normal([ params.cx, params.cy ], [p.x, p.y ]);
  				if (!this.anticlockwise && (m == Infinity || m == -Infinity)) m *= -1;
  				return m;
  			};
  
  			this.pointAlongPathFrom = function (location, distance, absolute) {
  				var p = this.pointOnPath(location, absolute),
  					arcSpan = distance / circumference * 2 * Math.PI,
  					dir = this.anticlockwise ? -1 : 1,
  					startAngle = p.theta + (dir * arcSpan),
  					startX = params.cx + (this.radius * Math.cos(startAngle)),
  					startY = params.cy + (this.radius * Math.sin(startAngle));
  
  				return {x: startX, y: startY};
  			};
  		}