The S&P 500 stock market index, maintained by S&P Dow Jones index, comprises 505 common stocks issued by 500 large-cap company and traded on American stock exchanges (including the 30 company that compose the Dow Jones Industrial average), and covers about 80 percent of the American equity market by capitalization. The index constituents and the constituent weights are updated regularly use rules published by S&P Dow Jones index.

COMING SOON!

```
package org.gs.queue
import scala.reflect.ClassTag
/** Minimum priority queue with index
*
* @constructor creates a new IndexMinPQ with maximum number of elements
* @tparam A keys are generic and ordered
* @param nMax maximum number of elements
* @param ord implicit ordering
* @see [[https://algs4.cs.princeton.edu/24pq/IndexMinPQ.java.html]]
* @author Scala translation by Gary Struthers from Java by Robert Sedgewick and Kevin Wayne.
*/
class IndexMinPQ[A: ClassTag](nMax: Int)(implicit ord: Ordering[A]) extends IndexPriorityQueue[A](nMax) {
/** Add key to end of array then swim up to ordered position
*
* @param i index where key will be inserted if not already there
* @param key generic element
*/
def insert(i: Int, key: A): Unit = insert(i, key, greater)
/** returns index associated with min key */
def minIndex(): Int = index
/** returns min key */
def minKey(): A = topKey
/** returns min key and removes it from queue */
def delMin(): Int = delTop(greater)
/** Change key at index to new value, because it can be > or < current, it both swims and sinks
*
* @param i index
* @param key value
*/
def changeKey(i: Int, key: A): Unit = changeKey(i, key, greater)
/** Decrease key at index to new value, because it is < current, it swims
*
* @param i index
* @param key value
*/
def decreaseKey(i: Int, key: A): Unit = decreaseKey(i, key, greater)
/** Increase key at index to new value, because it is > current, it sinks
*
* @param i index
* @param key value
*/
def increaseKey(i: Int, key: A): Unit = increaseKey(i, key, greater)
/** Remove key at index
*
* @param i index
*/
def delete(i: Int): Unit = delete(i, greater)
/** check parent in position has left child at k * 2, right child at k * 2 + 1 */
def isMinHeap(): Boolean = checkHeap(greater)
/** returns keys in order */
def keys(): Seq[A] = getKeys
}
```