If I have a series of points as longitude and latitude, how would I calculate the center of all of those points?

# How to find the center of a number of geographic points

arcgis-js-apigeometrygislanguage-agnosticpoint

#### Related Solutions

The bit shifting operators do exactly what their name implies. They shift bits. Here's a brief (or not-so-brief) introduction to the different shift operators.

## The Operators

`>>`

is the arithmetic (or signed) right shift operator.`>>>`

is the logical (or unsigned) right shift operator.`<<`

is the left shift operator, and meets the needs of both logical and arithmetic shifts.

All of these operators can be applied to integer values (`int`

, `long`

, possibly `short`

and `byte`

or `char`

). In some languages, applying the shift operators to any datatype smaller than `int`

automatically resizes the operand to be an `int`

.

Note that `<<<`

is not an operator, because it would be redundant.

Also note that **C and C++ do not distinguish between the right shift operators**. They provide only the `>>`

operator, and the right-shifting behavior is implementation defined for signed types. The rest of the answer uses the C# / Java operators.

(In all mainstream C and C++ implementations including GCC and Clang/LLVM, `>>`

on signed types is arithmetic. Some code assumes this, but it isn't something the standard guarantees. It's not *undefined*, though; the standard requires implementations to define it one way or another. However, left shifts of negative signed numbers *is* undefined behaviour (signed integer overflow). So unless you need arithmetic right shift, it's usually a good idea to do your bit-shifting with unsigned types.)

## Left shift (<<)

Integers are stored, in memory, as a series of bits. For example, the number 6 stored as a 32-bit `int`

would be:

```
00000000 00000000 00000000 00000110
```

Shifting this bit pattern to the left one position (`6 << 1`

) would result in the number 12:

```
00000000 00000000 00000000 00001100
```

As you can see, the digits have shifted to the left by one position, and the last digit on the right is filled with a zero. You might also note that shifting left is equivalent to multiplication by powers of 2. So `6 << 1`

is equivalent to `6 * 2`

, and `6 << 3`

is equivalent to `6 * 8`

. A good optimizing compiler will replace multiplications with shifts when possible.

### Non-circular shifting

Please note that these are *not* circular shifts. Shifting this value to the left by one position (`3,758,096,384 << 1`

):

```
11100000 00000000 00000000 00000000
```

results in 3,221,225,472:

```
11000000 00000000 00000000 00000000
```

The digit that gets shifted "off the end" is lost. It does not wrap around.

## Logical right shift (>>>)

A logical right shift is the converse to the left shift. Rather than moving bits to the left, they simply move to the right. For example, shifting the number 12:

```
00000000 00000000 00000000 00001100
```

to the right by one position (`12 >>> 1`

) will get back our original 6:

```
00000000 00000000 00000000 00000110
```

So we see that shifting to the right is equivalent to division by powers of 2.

### Lost bits are gone

However, a shift cannot reclaim "lost" bits. For example, if we shift this pattern:

```
00111000 00000000 00000000 00000110
```

to the left 4 positions (`939,524,102 << 4`

), we get 2,147,483,744:

```
10000000 00000000 00000000 01100000
```

and then shifting back (`(939,524,102 << 4) >>> 4`

) we get 134,217,734:

```
00001000 00000000 00000000 00000110
```

We cannot get back our original value once we have lost bits.

# Arithmetic right shift (>>)

The arithmetic right shift is exactly like the logical right shift, except instead of padding with zero, it pads with the most significant bit. This is because the most significant bit is the *sign* bit, or the bit that distinguishes positive and negative numbers. By padding with the most significant bit, the arithmetic right shift is sign-preserving.

For example, if we interpret this bit pattern as a negative number:

```
10000000 00000000 00000000 01100000
```

we have the number -2,147,483,552. Shifting this to the right 4 positions with the arithmetic shift (-2,147,483,552 >> 4) would give us:

```
11111000 00000000 00000000 00000110
```

or the number -134,217,722.

So we see that we have preserved the sign of our negative numbers by using the arithmetic right shift, rather than the logical right shift. And once again, we see that we are performing division by powers of 2.

**(StartA <= EndB) and (EndA >= StartB)**

*Proof:*

Let ConditionA Mean that DateRange A Completely After DateRange B

```
_ |---- DateRange A ------|
|---Date Range B -----| _
```

(True if `StartA > EndB`

)

Let ConditionB Mean that DateRange A is Completely Before DateRange B

```
|---- DateRange A -----| _
_ |---Date Range B ----|
```

(True if `EndA < StartB`

)

Then Overlap exists if Neither A Nor B is true -

(If one range is neither completely after the other,

nor completely before the other,
then they must overlap.)

Now one of De Morgan's laws says that:

`Not (A Or B)`

<=> `Not A And Not B`

Which translates to: `(StartA <= EndB) and (EndA >= StartB)`

NOTE: This includes conditions where the edges overlap exactly. If you wish to exclude that,

change the `>=`

operators to `>`

, and `<=`

to `<`

NOTE2. Thanks to @Baodad, see this blog, the actual overlap is least of:

{ `endA-startA`

, `endA - startB`

, `endB-startA`

, `endB - startB`

}

`(StartA <= EndB) and (EndA >= StartB)`

`(StartA <= EndB) and (StartB <= EndA)`

NOTE3. Thanks to @tomosius, a shorter version reads:

`DateRangesOverlap = max(start1, start2) < min(end1, end2)`

This is actually a syntactical shortcut for what is a longer implementation, which includes extra checks to verify that the start dates are on or before the endDates. Deriving this from above:

If start and end dates can be out of order, i.e., if it is possible that `startA > endA`

or `startB > endB`

, then you also have to check that they are in order, so that means you have to add two additional validity rules:

`(StartA <= EndB) and (StartB <= EndA) and (StartA <= EndA) and (StartB <= EndB)`

or:

`(StartA <= EndB) and (StartA <= EndA) and (StartB <= EndA) and (StartB <= EndB)`

or,

`(StartA <= Min(EndA, EndB) and (StartB <= Min(EndA, EndB))`

or:

`(Max(StartA, StartB) <= Min(EndA, EndB)`

But to implement `Min()`

and `Max()`

, you have to code, (using C ternary for terseness),:

`(StartA > StartB? Start A: StartB) <= (EndA < EndB? EndA: EndB)`

###### Related Question

- Calculate distance between 2 GPS coordinates
- What does it mean to “program to an interface”
- Equation for testing if a point is inside a circle
- Mysql – Fastest Way to Find Distance Between Two Lat/Long Points
- Ukkonen’s suffix tree algorithm in plain English
- How to determine whether the calculation of pi is accurate
- How to pair socks from a pile efficiently

## Best Solution

Geomidpoint covers 3 different methods for calculating this.