Convert *point* into an untyped point.
548202
def point2upoint(point):
    """"""
    upoint = [set(), set()]
    for v, val in point.items():
        upoint[val].add(v.uniqid)
    upoint[0] = frozenset(upoint[0])
    upoint[1] = frozenset(upoint[1])
    return tuple(upoint)
393481
function() {
    // convert to a poly point string
    for (var i = 0, il = this.value.length, array = []; i < il; i++)
      array.push(this.value[i].join(','))

    return array.join(' ')
  }
62248
function unwrapValue (val, type) {
  var basetype = type.type ? type.type : type;
  if (basetype == '@?') return createBlock(val, basetype);
  else if (basetype == '^?') return createWrapperPointer(val, type);
  else if (basetype == '@' || basetype == '#') {
    if(Buffer.isBuffer(val)) return val;
    return val ? val.pointer : null;
  }
  else if (basetype == ':') return selCache[val] || (selCache[val] = objc.sel_registerName(val));
  else if (val === true) return 1;
  else if (val === false) return 0;
  else return val;
}
1330177
function() {

            var points = this.points;
            var numPoints = points.length;
            if (numPoints === 0) return ''; // if points array is empty

            var output = '';
            for (var i = 0; i < numPoints; i++) {

                var point = points[i];
                output += point.x + ',' + point.y + ' ';
            }

            return output.trim();
        }
279208
def point(self, x, y):
        """"""
        shapeType = POINT
        pointShape = Shape(shapeType)
        pointShape.points.append([x, y])
        self.shape(pointShape)
891267
function normalizePoint(point) {

        return new g.Point(
            point.x === 0 ? 0 : Math.abs(point.x) / point.x,
            point.y === 0 ? 0 : Math.abs(point.y) / point.y
        );
    }
238416
def _convert_point(self, metric, ts, point, sd_point):
        """"""
        if (metric.descriptor.type == metric_descriptor.MetricDescriptorType
                .CUMULATIVE_DISTRIBUTION):

            sd_dist_val = sd_point.value.distribution_value
            sd_dist_val.count = point.value.count
            sd_dist_val.sum_of_squared_deviation =\
                point.value.sum_of_squared_deviation

            assert sd_dist_val.bucket_options.explicit_buckets.bounds == []
            sd_dist_val.bucket_options.explicit_buckets.bounds.extend(
                [0.0] +
                list(map(float, point.value.bucket_options.type_.bounds))
            )

            assert sd_dist_val.bucket_counts == []
            sd_dist_val.bucket_counts.extend(
                [0] +
                [bb.count for bb in point.value.buckets]
            )

        elif (metric.descriptor.type ==
              metric_descriptor.MetricDescriptorType.CUMULATIVE_INT64):
            sd_point.value.int64_value = int(point.value.value)

        elif (metric.descriptor.type ==
              metric_descriptor.MetricDescriptorType.CUMULATIVE_DOUBLE):
            sd_point.value.double_value = float(point.value.value)

        elif (metric.descriptor.type ==
              metric_descriptor.MetricDescriptorType.GAUGE_INT64):
            sd_point.value.int64_value = int(point.value.value)

        elif (metric.descriptor.type ==
              metric_descriptor.MetricDescriptorType.GAUGE_DOUBLE):
            sd_point.value.double_value = float(point.value.value)

        # TODO: handle SUMMARY metrics, #567
        else:  # pragma: NO COVER
            raise TypeError("Unsupported metric type: {}"
                            .format(metric.descriptor.type))

        end = point.timestamp
        if ts.start_timestamp is None:
            start = end
        else:
            start = datetime.strptime(ts.start_timestamp, EPOCH_PATTERN)

        timestamp_start = (start - EPOCH_DATETIME).total_seconds()
        timestamp_end = (end - EPOCH_DATETIME).total_seconds()

        sd_point.interval.end_time.seconds = int(timestamp_end)

        secs = sd_point.interval.end_time.seconds
        sd_point.interval.end_time.nanos = int((timestamp_end - secs) * 1e9)

        start_time = sd_point.interval.start_time
        start_time.seconds = int(timestamp_start)
        start_time.nanos = int((timestamp_start - start_time.seconds) * 1e9)
929150
def points_from_x0y0x1y1(xyxy):
    
    x0 = xyxy[0]
    y0 = xyxy[1]
    x1 = xyxy[2]
    y1 = xyxy[3]
    return "%s,%s %s,%s %s,%s %s,%s" % (
        x0, y0,
        x1, y0,
        x1, y1,
        x0, y1
    )
900144
def removePoint(self, point, preserveCurve=False):
        
        if not isinstance(point, int):
            point = self.points.index(point)
        point = normalizers.normalizeIndex(point)
        if point >= self._len__points():
            raise ValueError("No point located at index %d." % point)
        preserveCurve = normalizers.normalizeBoolean(preserveCurve)
        self._removePoint(point, preserveCurve)
269283
def convert_value(self, value):
        """"""
        if isinstance(value, str):
            value = value.replace(self.separator, '')
            if self.decimal_point not in value:
                return int(value)
            else:
                return float(value.replace(self.decimal_point, '.'))
        elif self.int_to_float:
            return float(value)
        else:
            return value
867527
function normalizePoint (point) {
            return {
                x: point.x * canvas.width,
                y: point.y * canvas.height
            };
        }
556969
public LatLng toLatLng(Point point) {
        point = toWgs84(point);
        LatLng latLng = new LatLng(point.getY(), point.getX());
        return latLng;
    }
63746
public static JoinPoint unWrapJoinPoint(final JoinPoint point) {
        var naked = point;
        while (naked.getArgs() != null && naked.getArgs().length > 0 && naked.getArgs()[0] instanceof JoinPoint) {
            naked = (JoinPoint) naked.getArgs()[0];
        }
        return naked;
    }
920452
function convertCodePoints(regexp) {
		return regexp.replace(/\\x\{([0-9a-fA-F]+)\}/g, function(m, chars) {
			// pad to four hex digits
			while (chars.length < 4) {
				chars = '0' + chars;
			}
			return '\\u' + chars;
		});
	}
77593
function fromCodePoint(cp) {
        return (cp < 0x10000) ? String.fromCharCode(cp) :
            String.fromCharCode(0xD800 + ((cp - 0x10000) >> 10)) +
            String.fromCharCode(0xDC00 + ((cp - 0x10000) & 1023));
    }
122668
def _convertPointsToSegments(points, willBeReversed=False):
    
    # get the last on curve
    previousOnCurve = None
    for point in reversed(points):
        if point.segmentType is not None:
            previousOnCurve = point.coordinates
            break
    assert previousOnCurve is not None
    # gather the segments
    offCurves = []
    segments = []
    for point in points:
        # off curve, hold.
        if point.segmentType is None:
            offCurves.append(point)
        else:
            segment = InputSegment(
                points=offCurves + [point],
                previousOnCurve=previousOnCurve,
                willBeReversed=willBeReversed
            )
            segments.append(segment)
            offCurves = []
            previousOnCurve = point.coordinates
    assert not offCurves
    return segments
829041
def _serialize_fields(point):
    """"""
    output = []
    for k, v in point['fields'].items():
        k = escape(k, key_escape)
        if isinstance(v, bool):
            output.append(f'{k}={v}')
        elif isinstance(v, int):
            output.append(f'{k}={v}i')
        elif isinstance(v, str):
            output.append(f'{k}="{v.translate(str_escape)}"')
        elif v is None:
            # Empty values
            continue
        else:
            # Floats
            output.append(f'{k}={v}')
    return ','.join(output)