code stringlengths 114 1.05M | path stringlengths 3 312 | quality_prob float64 0.5 0.99 | learning_prob float64 0.2 1 | filename stringlengths 3 168 | kind stringclasses 1 value |
|---|---|---|---|---|---|
package msgraph
// ProvisioningStepType undocumented
type ProvisioningStepType int
const (
// ProvisioningStepTypeVImport undocumented
ProvisioningStepTypeVImport ProvisioningStepType = 0
// ProvisioningStepTypeVScoping undocumented
ProvisioningStepTypeVScoping ProvisioningStepType = 1
// ProvisioningStepTypeVMatching undocumented
ProvisioningStepTypeVMatching ProvisioningStepType = 2
// ProvisioningStepTypeVProcessing undocumented
ProvisioningStepTypeVProcessing ProvisioningStepType = 3
// ProvisioningStepTypeVReferenceResolution undocumented
ProvisioningStepTypeVReferenceResolution ProvisioningStepType = 4
// ProvisioningStepTypeVExport undocumented
ProvisioningStepTypeVExport ProvisioningStepType = 5
// ProvisioningStepTypeVUnknownFutureValue undocumented
ProvisioningStepTypeVUnknownFutureValue ProvisioningStepType = 6
)
// ProvisioningStepTypePImport returns a pointer to ProvisioningStepTypeVImport
func ProvisioningStepTypePImport() *ProvisioningStepType {
v := ProvisioningStepTypeVImport
return &v
}
// ProvisioningStepTypePScoping returns a pointer to ProvisioningStepTypeVScoping
func ProvisioningStepTypePScoping() *ProvisioningStepType {
v := ProvisioningStepTypeVScoping
return &v
}
// ProvisioningStepTypePMatching returns a pointer to ProvisioningStepTypeVMatching
func ProvisioningStepTypePMatching() *ProvisioningStepType {
v := ProvisioningStepTypeVMatching
return &v
}
// ProvisioningStepTypePProcessing returns a pointer to ProvisioningStepTypeVProcessing
func ProvisioningStepTypePProcessing() *ProvisioningStepType {
v := ProvisioningStepTypeVProcessing
return &v
}
// ProvisioningStepTypePReferenceResolution returns a pointer to ProvisioningStepTypeVReferenceResolution
func ProvisioningStepTypePReferenceResolution() *ProvisioningStepType {
v := ProvisioningStepTypeVReferenceResolution
return &v
}
// ProvisioningStepTypePExport returns a pointer to ProvisioningStepTypeVExport
func ProvisioningStepTypePExport() *ProvisioningStepType {
v := ProvisioningStepTypeVExport
return &v
}
// ProvisioningStepTypePUnknownFutureValue returns a pointer to ProvisioningStepTypeVUnknownFutureValue
func ProvisioningStepTypePUnknownFutureValue() *ProvisioningStepType {
v := ProvisioningStepTypeVUnknownFutureValue
return &v
} | beta/ProvisioningStepTypeEnum.go | 0.53777 | 0.492798 | ProvisioningStepTypeEnum.go | starcoder |
package modify
import (
"github.com/ozonru/file.d/cfg"
"github.com/ozonru/file.d/fd"
"github.com/ozonru/file.d/pipeline"
"go.uber.org/zap"
)
/*{ introduction
It modifies the content for a field. It works only with strings.
You can provide an unlimited number of config parameters. Each parameter handled as `cfg.FieldSelector`:`cfg.Substitution`.
**Example:**
```yaml
pipelines:
example_pipeline:
...
actions:
- type: modify
my_object.field.subfield: value is ${another_object.value}.
...
```
The resulting event could look like:
```
{
"my_object": {
"field": {
"subfield":"value is 666."
}
},
"another_object": {
"value": 666
}
```
}*/
type Plugin struct {
config *Config
logger *zap.SugaredLogger
ops map[string][]cfg.SubstitutionOp
buf []byte
}
type Config map[string]string
func init() {
fd.DefaultPluginRegistry.RegisterAction(&pipeline.PluginStaticInfo{
Type: "modify",
Factory: factory,
})
}
func factory() (pipeline.AnyPlugin, pipeline.AnyConfig) {
return &Plugin{}, &Config{}
}
func (p *Plugin) Start(config pipeline.AnyConfig, params *pipeline.ActionPluginParams) {
p.config = config.(*Config)
p.ops = make(map[string][]cfg.SubstitutionOp)
p.logger = params.Logger
for key, value := range *p.config {
ops, err := cfg.ParseSubstitution(value)
if err != nil {
p.logger.Fatalf("can't parse substitution: %s", err.Error())
}
if len(ops) == 0 {
continue
}
p.ops[key] = ops
}
}
func (p *Plugin) Stop() {
}
func (p *Plugin) Do(event *pipeline.Event) pipeline.ActionResult {
for field, list := range p.ops {
p.buf = p.buf[:0]
for _, op := range list {
switch op.Kind {
case cfg.SubstitutionOpKindRaw:
p.buf = append(p.buf, op.Data[0]...)
case cfg.SubstitutionOpKindField:
p.buf = append(p.buf, event.Root.Dig(op.Data...).AsBytes()...)
default:
p.logger.Panicf("unknown substitution kind %d", op.Kind)
}
}
event.Root.AddFieldNoAlloc(event.Root, field).MutateToBytesCopy(event.Root, p.buf)
}
return pipeline.ActionPass
} | plugin/action/modify/modify.go | 0.72662 | 0.468183 | modify.go | starcoder |
package tpdu
// Deliver represents a SMS-Deliver PDU as defined in 3GPP TS 23.038 Section 9.2.2.1.
type Deliver struct {
TPDU
OA Address
// The SCTS timestamp indicates the time the SMS was sent.
// The time is the originator's local time, the timezone of which may differ from the
// receiver's.
SCTS Timestamp
}
// NewDeliver creates a Deliver TPDU and initialises non-zero fields.
func NewDeliver() *Deliver {
return &Deliver{TPDU: TPDU{FirstOctet: byte(MtDeliver)}}
}
// MaxUDL returns the maximum number of octets that can be encoded into the UD.
// Note that for 7bit encoding this can result in up to 160 septets.
func (d *Deliver) MaxUDL() int {
return 140
}
// MarshalBinary marshals a SMS-Deliver PDU into the corresponding byte array.
func (d *Deliver) MarshalBinary() ([]byte, error) {
b := []byte{d.FirstOctet}
oa, err := d.OA.MarshalBinary()
if err != nil {
return nil, EncodeError("oa", err)
}
b = append(b, oa...)
b = append(b, d.PID, d.DCS)
scts, err := d.SCTS.MarshalBinary()
if err != nil {
return nil, EncodeError("scts", err)
}
b = append(b, scts...)
ud, err := d.encodeUserData()
if err != nil {
return nil, EncodeError("ud", err)
}
b = append(b, ud...)
return b, nil
}
// UnmarshalBinary unmarshals a SMS-Deliver PDU from the corresponding byte array.
// In the case of error the Deliver will be partially unmarshalled, up to
// the point that the decoding error was detected.
func (d *Deliver) UnmarshalBinary(src []byte) error {
if len(src) < 1 {
return DecodeError("firstOctet", 0, ErrUnderflow)
}
d.FirstOctet = src[0]
ri := 1
n, err := d.OA.UnmarshalBinary(src[ri:])
if err != nil {
return DecodeError("oa", ri, err)
}
ri += n
if len(src) <= ri {
return DecodeError("pid", ri, ErrUnderflow)
}
d.PID = src[ri]
ri++
if len(src) <= ri {
return DecodeError("dcs", ri, ErrUnderflow)
}
d.DCS = src[ri]
ri++
if len(src) < ri+7 {
return DecodeError("scts", ri, ErrUnderflow)
}
err = d.SCTS.UnmarshalBinary(src[ri : ri+7])
if err != nil {
return DecodeError("scts", ri, err)
}
ri += 7
err = d.decodeUserData(src[ri:])
if err != nil {
return DecodeError("ud", ri, err)
}
return nil
}
func decodeDeliver(src []byte) (interface{}, error) {
d := NewDeliver()
if err := d.UnmarshalBinary(src); err != nil {
return nil, err
}
return d, nil
}
// RegisterDeliverDecoder registers a decoder for the Deliver TPDU.
func RegisterDeliverDecoder(d *Decoder) error {
return d.RegisterDecoder(MtDeliver, MT, decodeDeliver)
}
// RegisterReservedDecoder registers a decoder for the Deliver TPDU for the Reserved message type.
func RegisterReservedDecoder(d *Decoder) error {
return d.RegisterDecoder(MtReserved, MT, decodeDeliver)
} | encoding/tpdu/deliver.go | 0.793626 | 0.599573 | deliver.go | starcoder |
package bcolumn
import (
"github.com/tobgu/qframe/internal/column"
"github.com/tobgu/qframe/internal/hash"
"github.com/tobgu/qframe/internal/index"
"github.com/tobgu/qframe/qerrors"
"github.com/tobgu/qframe/types"
"reflect"
"strconv"
)
func (c Comparable) Compare(i, j uint32) column.CompareResult {
x, y := c.data[i], c.data[j]
if x == y {
return column.Equal
}
if x {
return c.gtValue
}
return c.ltValue
}
func (c Comparable) Hash(i uint32, seed uint64) uint64 {
if c.data[i] {
b := [1]byte{1}
return hash.HashBytes(b[:], seed)
}
b := [1]byte{0}
return hash.HashBytes(b[:], seed)
}
func (c Column) DataType() types.DataType {
return types.Bool
}
func (c Column) StringAt(i uint32, _ string) string {
return strconv.FormatBool(c.data[i])
}
func (c Column) AppendByteStringAt(buf []byte, i uint32) []byte {
return strconv.AppendBool(buf, c.data[i])
}
func (c Column) ByteSize() int {
// Slice header + data
return 2*8 + cap(c.data)
}
func (c Column) Equals(index index.Int, other column.Column, otherIndex index.Int) bool {
otherI, ok := other.(Column)
if !ok {
return false
}
for ix, x := range index {
if c.data[x] != otherI.data[otherIndex[ix]] {
return false
}
}
return true
}
func (c Column) filterBuiltIn(index index.Int, comparator string, comparatee interface{}, bIndex index.Bool) error {
switch t := comparatee.(type) {
case bool:
compFunc, ok := filterFuncs[comparator]
if !ok {
return qerrors.New("filter bool", "invalid comparison operator for bool, %v", comparator)
}
compFunc(index, c.data, t, bIndex)
case Column:
compFunc, ok := filterFuncs2[comparator]
if !ok {
return qerrors.New("filter bool", "invalid comparison operator for bool, %v", comparator)
}
compFunc(index, c.data, t.data, bIndex)
default:
return qerrors.New("filter bool", "invalid comparison value type %v", reflect.TypeOf(comparatee))
}
return nil
}
func (c Column) filterCustom1(index index.Int, fn func(bool) bool, bIndex index.Bool) {
for i, x := range bIndex {
if !x {
bIndex[i] = fn(c.data[index[i]])
}
}
}
func (c Column) filterCustom2(index index.Int, fn func(bool, bool) bool, comparatee interface{}, bIndex index.Bool) error {
otherC, ok := comparatee.(Column)
if !ok {
return qerrors.New("filter bool", "expected comparatee to be bool column, was %v", reflect.TypeOf(comparatee))
}
for i, x := range bIndex {
if !x {
bIndex[i] = fn(c.data[index[i]], otherC.data[index[i]])
}
}
return nil
}
func (c Column) Filter(index index.Int, comparator interface{}, comparatee interface{}, bIndex index.Bool) error {
var err error
switch t := comparator.(type) {
case string:
err = c.filterBuiltIn(index, t, comparatee, bIndex)
case func(bool) bool:
c.filterCustom1(index, t, bIndex)
case func(bool, bool) bool:
err = c.filterCustom2(index, t, comparatee, bIndex)
default:
err = qerrors.New("filter bool", "invalid filter type %v", reflect.TypeOf(comparator))
}
return err
}
func (c Column) FunctionType() types.FunctionType {
return types.FunctionTypeBool
} | internal/bcolumn/column.go | 0.605099 | 0.437223 | column.go | starcoder |
package blockchain
// BlockHeader contains metadata about a block
import (
"bytes"
"encoding/json"
"github.com/ubclaunchpad/cumulus/common/util"
)
// DefaultBlockSize is the default block size, can be augmented by the user.
const DefaultBlockSize = 1 << 18
// BlockHeader contains metadata about a block
type BlockHeader struct {
// BlockNumber is the position of the block within the blockchain
BlockNumber uint32
// LastBlock is the hash of the previous block
LastBlock Hash
// Target is the current target
Target Hash
// Time is represented as the number of seconds elapsed
// since January 1, 1970 UTC.
Time uint32
// Nonce starts at 0 and increments by 1 for every hash when mining
Nonce uint64
// ExtraData is an extra field that can be filled with arbitrary data to
// be stored in the block
ExtraData []byte
}
// Marshal converts a BlockHeader to a byte slice
func (bh *BlockHeader) Marshal() []byte {
var buf []byte
buf = util.AppendUint32(buf, bh.BlockNumber)
buf = append(buf, bh.LastBlock.Marshal()...)
buf = append(buf, bh.Target.Marshal()...)
buf = util.AppendUint32(buf, bh.Time)
buf = util.AppendUint64(buf, bh.Nonce)
buf = append(buf, bh.ExtraData...)
return buf
}
// Equal returns true if all the fields (other than ExtraData) in each of
// the BlockHeaders match, and false otherwise.
func (bh *BlockHeader) Equal(otherHeader *BlockHeader) bool {
return bh.BlockNumber == otherHeader.BlockNumber &&
bh.LastBlock == otherHeader.LastBlock &&
bh.Target == otherHeader.Target &&
bh.Time == otherHeader.Time &&
bh.Nonce == otherHeader.Nonce
}
// Len returns the length in bytes of the BlockHeader.
func (bh *BlockHeader) Len() int {
return len(bh.Marshal())
}
// Block represents a block in the blockchain. Contains transactions and header metadata.
type Block struct {
BlockHeader
Transactions []*Transaction
}
// Len returns the length in bytes of the Block.
func (b *Block) Len() int {
return len(b.Marshal())
}
// Marshal converts a Block to a byte slice.
func (b Block) Marshal() []byte {
var buf []byte
buf = append(buf, b.BlockHeader.Marshal()...)
for _, t := range b.Transactions {
buf = append(buf, t.Marshal()...)
}
return buf
}
// DecodeBlockJSON returns a block read from the given marshalled block, or an
// error if blockBytes cannot be decoded as JSON.
func DecodeBlockJSON(blockBytes []byte) (*Block, error) {
var b Block
dec := json.NewDecoder(bytes.NewReader(blockBytes))
dec.UseNumber()
err := dec.Decode(&b)
return &b, err
}
// ContainsTransaction returns true and the transaction itself if the Block
// contains the transaction.
func (b *Block) ContainsTransaction(t *Transaction) (bool, uint32) {
for i, tr := range b.Transactions {
if HashSum(t) == HashSum(tr) {
return true, uint32(i)
}
}
return false, 0
}
// GetCloudBaseTransaction returns the CloudBase transaction within a block
func (b *Block) GetCloudBaseTransaction() *Transaction {
return b.Transactions[0]
}
// GetTransactionsFrom returns all the transactions from the given sender in
// the given block.
func (b *Block) GetTransactionsFrom(sender string) []*Transaction {
txns := make([]*Transaction, 0)
for _, txn := range b.Transactions {
if txn.TxBody.Sender.Repr() == sender {
txns = append(txns, txn)
}
}
return txns
}
// GetTransactionsTo returns all the transactions with outputs to the given
// recipient in the given block.
func (b *Block) GetTransactionsTo(recipient string) []*Transaction {
txns := make([]*Transaction, 0)
for _, txn := range b.Transactions {
if txn.GetTotalOutputFor(recipient) > 0 {
txns = append(txns, txn)
}
}
return txns
}
// GetTotalInputFrom returns the total input from the given sender in the given
// block. Returns an error if the input to one or more of the inputs to the
// transactions in the given block could not be found in the blockchain.
func (b *Block) GetTotalInputFrom(sender string, bc *BlockChain) (uint64, error) {
totalInput := uint64(0)
for _, t := range b.Transactions {
if t.Sender.Repr() == sender {
input, err := t.GetTotalInput(bc)
if err != nil {
return 0, err
}
totalInput += input
}
}
return totalInput, nil
}
// GetTotalOutputFor sums the outputs referenced to a specific recipient in the
// given block. recipient is an address checksum hex string.
func (b *Block) GetTotalOutputFor(recipient string) uint64 {
total := uint64(0)
for _, txn := range b.Transactions {
total += txn.GetTotalOutputFor(recipient)
}
return total
} | blockchain/block.go | 0.752286 | 0.461563 | block.go | starcoder |
package ameda
import (
"fmt"
"reflect"
)
// InterfaceToInterfacePtr converts interface to *interface.
func InterfaceToInterfacePtr(i interface{}) *interface{} {
return &i
}
// InterfaceToString converts interface to string.
func InterfaceToString(i interface{}) string {
return fmt.Sprintf("%v", i)
}
// InterfaceToStringPtr converts interface to *string.
func InterfaceToStringPtr(i interface{}) *string {
v := InterfaceToString(i)
return &v
}
// InterfaceToBool converts interface to bool.
// NOTE:
// 0 is false, other numbers are true
func InterfaceToBool(i interface{}, emptyAsFalse ...bool) (bool, error) {
switch v := i.(type) {
case bool:
return v, nil
case nil:
return false, nil
case float32:
return Float32ToBool(v), nil
case float64:
return Float64ToBool(v), nil
case int:
return IntToBool(v), nil
case int8:
return Int8ToBool(v), nil
case int16:
return Int16ToBool(v), nil
case int32:
return Int32ToBool(v), nil
case int64:
return Int64ToBool(v), nil
case uint:
return UintToBool(v), nil
case uint8:
return Uint8ToBool(v), nil
case uint16:
return Uint16ToBool(v), nil
case uint32:
return Uint32ToBool(v), nil
case uint64:
return Uint64ToBool(v), nil
case uintptr:
return v != 0, nil
case string:
return StringToBool(v, emptyAsFalse...)
default:
r := IndirectValue(reflect.ValueOf(i))
switch r.Kind() {
case reflect.Bool:
return r.Bool(), nil
case reflect.Invalid:
return false, nil
case reflect.Float32, reflect.Float64:
return Float64ToBool(r.Float()), nil
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return Int64ToBool(r.Int()), nil
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
return Uint64ToBool(r.Uint()), nil
case reflect.String:
return StringToBool(r.String(), emptyAsFalse...)
}
if isEmptyAsZero(emptyAsFalse) {
return !isZero(r), nil
}
return false, fmt.Errorf("cannot convert %#v of type %T to bool", i, i)
}
}
// InterfaceToBoolPtr converts interface to *bool.
// NOTE:
// 0 is false, other numbers are true
func InterfaceToBoolPtr(i interface{}, emptyAsFalse ...bool) (*bool, error) {
r, err := InterfaceToBool(i, emptyAsFalse...)
return &r, err
}
// InterfaceToFloat32 converts interface to float32.
func InterfaceToFloat32(i interface{}, emptyStringAsZero ...bool) (float32, error) {
switch v := i.(type) {
case bool:
return BoolToFloat32(v), nil
case nil:
return 0, nil
case int:
return IntToFloat32(v), nil
case int8:
return Int8ToFloat32(v), nil
case int16:
return Int16ToFloat32(v), nil
case int32:
return Int32ToFloat32(v), nil
case int64:
return Int64ToFloat32(v), nil
case uint:
return UintToFloat32(v), nil
case uint8:
return Uint8ToFloat32(v), nil
case uint16:
return Uint16ToFloat32(v), nil
case uint32:
return Uint32ToFloat32(v), nil
case uint64:
return Uint64ToFloat32(v), nil
case uintptr:
return UintToFloat32(uint(v)), nil
case string:
return StringToFloat32(v, emptyStringAsZero...)
default:
r := IndirectValue(reflect.ValueOf(i))
switch r.Kind() {
case reflect.Bool:
return BoolToFloat32(r.Bool()), nil
case reflect.Invalid:
return 0, nil
case reflect.Float32:
return float32(r.Float()), nil
case reflect.Float64:
return Float64ToFloat32(r.Float())
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return Int64ToFloat32(r.Int()), nil
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
return Uint64ToFloat32(r.Uint()), nil
case reflect.String:
return StringToFloat32(r.String(), emptyStringAsZero...)
}
if isEmptyAsZero(emptyStringAsZero) {
return BoolToFloat32(!isZero(r)), nil
}
return 0, fmt.Errorf("cannot convert %#v of type %T to float32", i, i)
}
}
// InterfaceToFloat32Ptr converts interface to *float32.
func InterfaceToFloat32Ptr(i interface{}, emptyAsFalse ...bool) (*float32, error) {
r, err := InterfaceToFloat32(i, emptyAsFalse...)
return &r, err
}
// InterfaceToFloat64 converts interface to float64.
func InterfaceToFloat64(i interface{}, emptyStringAsZero ...bool) (float64, error) {
switch v := i.(type) {
case bool:
return BoolToFloat64(v), nil
case nil:
return 0, nil
case int:
return IntToFloat64(v), nil
case int8:
return Int8ToFloat64(v), nil
case int16:
return Int16ToFloat64(v), nil
case int32:
return Int32ToFloat64(v), nil
case int64:
return Int64ToFloat64(v), nil
case uint:
return UintToFloat64(v), nil
case uint8:
return Uint8ToFloat64(v), nil
case uint16:
return Uint16ToFloat64(v), nil
case uint32:
return Uint32ToFloat64(v), nil
case uint64:
return Uint64ToFloat64(v), nil
case uintptr:
return UintToFloat64(uint(v)), nil
case string:
return StringToFloat64(v, emptyStringAsZero...)
default:
r := IndirectValue(reflect.ValueOf(i))
switch r.Kind() {
case reflect.Bool:
return BoolToFloat64(r.Bool()), nil
case reflect.Invalid:
return 0, nil
case reflect.Float32, reflect.Float64:
return r.Float(), nil
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return Int64ToFloat64(r.Int()), nil
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
return Uint64ToFloat64(r.Uint()), nil
case reflect.String:
return StringToFloat64(r.String(), emptyStringAsZero...)
}
if isEmptyAsZero(emptyStringAsZero) {
return BoolToFloat64(!isZero(r)), nil
}
return 0, fmt.Errorf("cannot convert %#v of type %T to float64", i, i)
}
}
// InterfaceToFloat64Ptr converts interface to *float64.
func InterfaceToFloat64Ptr(i interface{}, emptyAsFalse ...bool) (*float64, error) {
r, err := InterfaceToFloat64(i, emptyAsFalse...)
return &r, err
}
// InterfaceToInt converts interface to int.
func InterfaceToInt(i interface{}, emptyStringAsZero ...bool) (int, error) {
switch v := i.(type) {
case bool:
return BoolToInt(v), nil
case nil:
return 0, nil
case int:
return v, nil
case int8:
return Int8ToInt(v), nil
case int16:
return Int16ToInt(v), nil
case int32:
return Int32ToInt(v), nil
case int64:
return Int64ToInt(v)
case uint:
return UintToInt(v)
case uint8:
return Uint8ToInt(v), nil
case uint16:
return Uint16ToInt(v), nil
case uint32:
return Uint32ToInt(v), nil
case uint64:
return Uint64ToInt(v), nil
case uintptr:
return UintToInt(uint(v))
case string:
return StringToInt(v, emptyStringAsZero...)
default:
r := IndirectValue(reflect.ValueOf(i))
switch r.Kind() {
case reflect.Bool:
return BoolToInt(r.Bool()), nil
case reflect.Invalid:
return 0, nil
case reflect.Float32, reflect.Float64:
return Float64ToInt(r.Float())
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return Int64ToInt(r.Int())
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
return Uint64ToInt(r.Uint()), nil
case reflect.String:
return StringToInt(r.String(), emptyStringAsZero...)
}
if isEmptyAsZero(emptyStringAsZero) {
return BoolToInt(!isZero(r)), nil
}
return 0, fmt.Errorf("cannot convert %#v of type %T to int", i, i)
}
}
// InterfaceToIntPtr converts interface to *float64.
func InterfaceToIntPtr(i interface{}, emptyAsFalse ...bool) (*int, error) {
r, err := InterfaceToInt(i, emptyAsFalse...)
return &r, err
}
// InterfaceToInt8 converts interface to int8.
func InterfaceToInt8(i interface{}, emptyStringAsZero ...bool) (int8, error) {
switch v := i.(type) {
case bool:
return BoolToInt8(v), nil
case nil:
return 0, nil
case int:
return IntToInt8(v)
case int8:
return v, nil
case int16:
return Int16ToInt8(v)
case int32:
return Int32ToInt8(v)
case int64:
return Int64ToInt8(v)
case uint:
return UintToInt8(v)
case uint8:
return Uint8ToInt8(v)
case uint16:
return Uint16ToInt8(v)
case uint32:
return Uint32ToInt8(v)
case uint64:
return Uint64ToInt8(v)
case uintptr:
return UintToInt8(uint(v))
case string:
return StringToInt8(v, emptyStringAsZero...)
default:
r := IndirectValue(reflect.ValueOf(i))
switch r.Kind() {
case reflect.Bool:
return BoolToInt8(r.Bool()), nil
case reflect.Invalid:
return 0, nil
case reflect.Float32, reflect.Float64:
return Float64ToInt8(r.Float())
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return Int64ToInt8(r.Int())
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
return Uint64ToInt8(r.Uint())
case reflect.String:
return StringToInt8(r.String(), emptyStringAsZero...)
}
if isEmptyAsZero(emptyStringAsZero) {
return BoolToInt8(!isZero(r)), nil
}
return 0, fmt.Errorf("cannot convert %#v of type %T to int8", i, i)
}
}
// InterfaceToInt8Ptr converts interface to *int8.
func InterfaceToInt8Ptr(i interface{}, emptyAsFalse ...bool) (*int8, error) {
r, err := InterfaceToInt8(i, emptyAsFalse...)
return &r, err
}
// InterfaceToInt16 converts interface to int16.
func InterfaceToInt16(i interface{}, emptyStringAsZero ...bool) (int16, error) {
switch v := i.(type) {
case bool:
return BoolToInt16(v), nil
case nil:
return 0, nil
case int:
return IntToInt16(v)
case int8:
return Int8ToInt16(v), nil
case int16:
return v, nil
case int32:
return Int32ToInt16(v)
case int64:
return Int64ToInt16(v)
case uint:
return UintToInt16(v)
case uint8:
return Uint8ToInt16(v), nil
case uint16:
return Uint16ToInt16(v)
case uint32:
return Uint32ToInt16(v)
case uint64:
return Uint64ToInt16(v)
case uintptr:
return UintToInt16(uint(v))
case string:
return StringToInt16(v, emptyStringAsZero...)
default:
r := IndirectValue(reflect.ValueOf(i))
switch r.Kind() {
case reflect.Bool:
return BoolToInt16(r.Bool()), nil
case reflect.Invalid:
return 0, nil
case reflect.Float32, reflect.Float64:
return Float64ToInt16(r.Float())
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return Int64ToInt16(r.Int())
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
return Uint64ToInt16(r.Uint())
case reflect.String:
return StringToInt16(r.String(), emptyStringAsZero...)
}
if isEmptyAsZero(emptyStringAsZero) {
return BoolToInt16(!isZero(r)), nil
}
return 0, fmt.Errorf("cannot convert %#v of type %T to int16", i, i)
}
}
// InterfaceToInt16Ptr converts interface to *int16.
func InterfaceToInt16Ptr(i interface{}, emptyAsFalse ...bool) (*int16, error) {
r, err := InterfaceToInt16(i, emptyAsFalse...)
return &r, err
}
// InterfaceToInt32 converts interface to int32.
func InterfaceToInt32(i interface{}, emptyStringAsZero ...bool) (int32, error) {
switch v := i.(type) {
case bool:
return BoolToInt32(v), nil
case nil:
return 0, nil
case int:
return IntToInt32(v)
case int8:
return Int8ToInt32(v), nil
case int16:
return Int16ToInt32(v), nil
case int32:
return v, nil
case int64:
return Int64ToInt32(v)
case uint:
return UintToInt32(v)
case uint8:
return Uint8ToInt32(v), nil
case uint16:
return Uint16ToInt32(v), nil
case uint32:
return Uint32ToInt32(v)
case uint64:
return Uint64ToInt32(v)
case uintptr:
return UintToInt32(uint(v))
case string:
return StringToInt32(v, emptyStringAsZero...)
default:
r := IndirectValue(reflect.ValueOf(i))
switch r.Kind() {
case reflect.Bool:
return BoolToInt32(r.Bool()), nil
case reflect.Invalid:
return 0, nil
case reflect.Float32, reflect.Float64:
return Float64ToInt32(r.Float())
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return Int64ToInt32(r.Int())
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
return Uint64ToInt32(r.Uint())
case reflect.String:
return StringToInt32(r.String(), emptyStringAsZero...)
}
if isEmptyAsZero(emptyStringAsZero) {
return BoolToInt32(!isZero(r)), nil
}
return 0, fmt.Errorf("cannot convert %#v of type %T to int32", i, i)
}
}
// InterfaceToInt32Ptr converts interface to *int32.
func InterfaceToInt32Ptr(i interface{}, emptyAsFalse ...bool) (*int32, error) {
r, err := InterfaceToInt32(i, emptyAsFalse...)
return &r, err
}
// InterfaceToInt64 converts interface to int64.
func InterfaceToInt64(i interface{}, emptyStringAsZero ...bool) (int64, error) {
switch v := i.(type) {
case bool:
return BoolToInt64(v), nil
case nil:
return 0, nil
case int:
return IntToInt64(v), nil
case int8:
return Int8ToInt64(v), nil
case int16:
return Int16ToInt64(v), nil
case int32:
return Int32ToInt64(v), nil
case int64:
return v, nil
case uint:
return UintToInt64(v)
case uint8:
return Uint8ToInt64(v), nil
case uint16:
return Uint16ToInt64(v), nil
case uint32:
return Uint32ToInt64(v), nil
case uint64:
return Uint64ToInt64(v)
case uintptr:
return UintToInt64(uint(v))
case string:
return StringToInt64(v, emptyStringAsZero...)
default:
r := IndirectValue(reflect.ValueOf(i))
switch r.Kind() {
case reflect.Bool:
return BoolToInt64(r.Bool()), nil
case reflect.Invalid:
return 0, nil
case reflect.Float32, reflect.Float64:
return Float64ToInt64(r.Float())
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return r.Int(), nil
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
return Uint64ToInt64(r.Uint())
case reflect.String:
return StringToInt64(r.String(), emptyStringAsZero...)
}
if isEmptyAsZero(emptyStringAsZero) {
return BoolToInt64(!isZero(r)), nil
}
return 0, fmt.Errorf("cannot convert %#v of type %T to int64", i, i)
}
}
// InterfaceToInt64Ptr converts interface to *int64.
func InterfaceToInt64Ptr(i interface{}, emptyAsFalse ...bool) (*int64, error) {
r, err := InterfaceToInt64(i, emptyAsFalse...)
return &r, err
}
// InterfaceToUint converts interface to uint.
func InterfaceToUint(i interface{}, emptyStringAsZero ...bool) (uint, error) {
switch v := i.(type) {
case bool:
return BoolToUint(v), nil
case nil:
return 0, nil
case int:
return IntToUint(v)
case int8:
return Int8ToUint(v)
case int16:
return Int16ToUint(v)
case int32:
return Int32ToUint(v)
case int64:
return Int64ToUint(v)
case uint:
return v, nil
case uint8:
return Uint8ToUint(v), nil
case uint16:
return Uint16ToUint(v), nil
case uint32:
return Uint32ToUint(v), nil
case uint64:
return Uint64ToUint(v)
case uintptr:
return uint(v), nil
case string:
return StringToUint(v, emptyStringAsZero...)
default:
r := IndirectValue(reflect.ValueOf(i))
switch r.Kind() {
case reflect.Bool:
return BoolToUint(r.Bool()), nil
case reflect.Invalid:
return 0, nil
case reflect.Float32, reflect.Float64:
return Float64ToUint(r.Float())
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return Int64ToUint(r.Int())
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
return Uint64ToUint(r.Uint())
case reflect.String:
return StringToUint(r.String(), emptyStringAsZero...)
}
if isEmptyAsZero(emptyStringAsZero) {
return BoolToUint(!isZero(r)), nil
}
return 0, fmt.Errorf("cannot convert %#v of type %T to uint", i, i)
}
}
// InterfaceToUintPtr converts interface to *uint.
func InterfaceToUintPtr(i interface{}, emptyAsFalse ...bool) (*uint, error) {
r, err := InterfaceToUint(i, emptyAsFalse...)
return &r, err
}
// InterfaceToUint8 converts interface to uint8.
func InterfaceToUint8(i interface{}, emptyStringAsZero ...bool) (uint8, error) {
switch v := i.(type) {
case bool:
return BoolToUint8(v), nil
case nil:
return 0, nil
case int:
return IntToUint8(v)
case int8:
return Int8ToUint8(v)
case int16:
return Int16ToUint8(v)
case int32:
return Int32ToUint8(v)
case int64:
return Int64ToUint8(v)
case uint:
return UintToUint8(v)
case uint8:
return v, nil
case uint16:
return Uint16ToUint8(v)
case uint32:
return Uint32ToUint8(v)
case uint64:
return Uint64ToUint8(v)
case uintptr:
return UintToUint8(uint(v))
case string:
return StringToUint8(v, emptyStringAsZero...)
default:
r := IndirectValue(reflect.ValueOf(i))
switch r.Kind() {
case reflect.Bool:
return BoolToUint8(r.Bool()), nil
case reflect.Invalid:
return 0, nil
case reflect.Float32, reflect.Float64:
return Float64ToUint8(r.Float())
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return Int64ToUint8(r.Int())
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
return Uint64ToUint8(r.Uint())
case reflect.String:
return StringToUint8(r.String(), emptyStringAsZero...)
}
if isEmptyAsZero(emptyStringAsZero) {
return BoolToUint8(!isZero(r)), nil
}
return 0, fmt.Errorf("cannot convert %#v of type %T to uint8", i, i)
}
}
// InterfaceToUint8Ptr converts interface to *uint8.
func InterfaceToUint8Ptr(i interface{}, emptyAsFalse ...bool) (*uint8, error) {
r, err := InterfaceToUint8(i, emptyAsFalse...)
return &r, err
}
// InterfaceToUint16 converts interface to uint16.
func InterfaceToUint16(i interface{}, emptyStringAsZero ...bool) (uint16, error) {
switch v := i.(type) {
case bool:
return BoolToUint16(v), nil
case nil:
return 0, nil
case int:
return IntToUint16(v)
case int8:
return Int8ToUint16(v)
case int16:
return Int16ToUint16(v)
case int32:
return Int32ToUint16(v)
case int64:
return Int64ToUint16(v)
case uint:
return UintToUint16(v)
case uint8:
return Uint8ToUint16(v), nil
case uint16:
return v, nil
case uint32:
return Uint32ToUint16(v)
case uint64:
return Uint64ToUint16(v)
case uintptr:
return UintToUint16(uint(v))
case string:
return StringToUint16(v, emptyStringAsZero...)
default:
r := IndirectValue(reflect.ValueOf(i))
switch r.Kind() {
case reflect.Bool:
return BoolToUint16(r.Bool()), nil
case reflect.Invalid:
return 0, nil
case reflect.Float32, reflect.Float64:
return Float64ToUint16(r.Float())
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return Int64ToUint16(r.Int())
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
return Uint64ToUint16(r.Uint())
case reflect.String:
return StringToUint16(r.String(), emptyStringAsZero...)
}
if isEmptyAsZero(emptyStringAsZero) {
return BoolToUint16(!isZero(r)), nil
}
return 0, fmt.Errorf("cannot convert %#v of type %T to uint16", i, i)
}
}
// InterfaceToUint16Ptr converts interface to *uint16.
func InterfaceToUint16Ptr(i interface{}, emptyAsFalse ...bool) (*uint16, error) {
r, err := InterfaceToUint16(i, emptyAsFalse...)
return &r, err
}
// InterfaceToUint32 converts interface to uint32.
func InterfaceToUint32(i interface{}, emptyStringAsZero ...bool) (uint32, error) {
switch v := i.(type) {
case bool:
return BoolToUint32(v), nil
case nil:
return 0, nil
case int:
return IntToUint32(v)
case int8:
return Int8ToUint32(v)
case int16:
return Int16ToUint32(v)
case int32:
return Int32ToUint32(v)
case int64:
return Int64ToUint32(v)
case uint:
return UintToUint32(v)
case uint8:
return Uint8ToUint32(v), nil
case uint16:
return Uint16ToUint32(v), nil
case uint32:
return v, nil
case uint64:
return Uint64ToUint32(v)
case uintptr:
return UintToUint32(uint(v))
case string:
return StringToUint32(v, emptyStringAsZero...)
default:
r := IndirectValue(reflect.ValueOf(i))
switch r.Kind() {
case reflect.Bool:
return BoolToUint32(r.Bool()), nil
case reflect.Invalid:
return 0, nil
case reflect.Float32, reflect.Float64:
return Float64ToUint32(r.Float())
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return Int64ToUint32(r.Int())
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
return Uint64ToUint32(r.Uint())
case reflect.String:
return StringToUint32(r.String(), emptyStringAsZero...)
}
if isEmptyAsZero(emptyStringAsZero) {
return BoolToUint32(!isZero(r)), nil
}
return 0, fmt.Errorf("cannot convert %#v of type %T to uint32", i, i)
}
}
// InterfaceToUint32Ptr converts interface to *uint32.
func InterfaceToUint32Ptr(i interface{}, emptyAsFalse ...bool) (*uint32, error) {
r, err := InterfaceToUint32(i, emptyAsFalse...)
return &r, err
}
// InterfaceToUint64 converts interface to uint64.
func InterfaceToUint64(i interface{}, emptyStringAsZero ...bool) (uint64, error) {
switch v := i.(type) {
case bool:
return BoolToUint64(v), nil
case nil:
return 0, nil
case int:
return IntToUint64(v)
case int8:
return Int8ToUint64(v)
case int16:
return Int16ToUint64(v)
case int32:
return Int32ToUint64(v)
case int64:
return Int64ToUint64(v)
case uint:
return UintToUint64(v), nil
case uint8:
return Uint8ToUint64(v), nil
case uint16:
return Uint16ToUint64(v), nil
case uint32:
return Uint32ToUint64(v), nil
case uint64:
return v, nil
case uintptr:
return UintToUint64(uint(v)), nil
case string:
return StringToUint64(v, emptyStringAsZero...)
default:
r := IndirectValue(reflect.ValueOf(i))
switch r.Kind() {
case reflect.Bool:
return BoolToUint64(r.Bool()), nil
case reflect.Invalid:
return 0, nil
case reflect.Float32, reflect.Float64:
return Float64ToUint64(r.Float())
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return Int64ToUint64(r.Int())
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
return r.Uint(), nil
case reflect.String:
return StringToUint64(r.String(), emptyStringAsZero...)
}
if isEmptyAsZero(emptyStringAsZero) {
return BoolToUint64(!isZero(r)), nil
}
return 0, fmt.Errorf("cannot convert %#v of type %T to uint64", i, i)
}
}
// InterfaceToUint64Ptr converts interface to *uint64.
func InterfaceToUint64Ptr(i interface{}, emptyAsFalse ...bool) (*uint64, error) {
r, err := InterfaceToUint64(i, emptyAsFalse...)
return &r, err
} | vendor/github.com/henrylee2cn/ameda/interface.go | 0.52342 | 0.438485 | interface.go | starcoder |
package xmath
import (
"fmt"
"strings"
)
type Matrix []Vector
// Diag creates a new diagonal Matrix with the given elements in the diagonal
func Diag(v Vector) Matrix {
m := Mat(len(v))
for i := range v {
m[i] = Vec(len(v))
m[i][i] = v[i]
}
return m
}
// Mat creates a newMatrix of the given dimension
func Mat(m int) Matrix {
mat := make([]Vector, m)
return mat
}
// T calculates the transpose of a matrix
func (m Matrix) T() Matrix {
n := Mat(len(m[0])).Of(len(m))
for i := range m {
for j := range m[i] {
n[j][i] = m[i][j]
}
}
return n
}
// Sum returns a vector that carries the sum of all elements for each row of the Matrix
func (m Matrix) Sum() Vector {
v := Vec(len(m))
for i := range m {
v[i] = m[i].Sum()
}
return v
}
// Add returns the addition operation on 2 matrices
func (m Matrix) Add(v Matrix) Matrix {
w := Mat(len(m))
for i := range m {
n := Vec(len(m[i]))
for j := 0; j < len(m[i]); j++ {
n[j] = m[i][j] + v[i][j]
}
w[i] = n
}
return w
}
// Dot returns the product of the given matrix with the matrix
func (m Matrix) Dot(v Matrix) Matrix {
w := Mat(len(m))
for i := range m {
for j := 0; j < len(v); j++ {
MustHaveSameSize(m[i], v[j])
w[i][j] = m[i].Dot(v[j])
}
}
return w
}
// Prod returns the cross product of the given vector with the matrix
func (m Matrix) Prod(v Vector) Vector {
w := Vec(len(m))
for i := range m {
MustHaveSameSize(m[i], v)
w[i] = m[i].Dot(v)
}
return w
}
// Mult multiplies each element of the matrix with the given factor
func (m Matrix) Mult(s float64) Matrix {
n := Mat(len(m))
for i := range m {
n[i] = m[i].Mult(s)
}
return n
}
// Of initialises the rows of the matrix with vectors of the given length
func (m Matrix) Of(n int) Matrix {
for i := 0; i < len(m); i++ {
m[i] = Vec(n)
}
return m
}
// With creates a matrix with the given vector replicated at each row
func (m Matrix) From(v Vector) Matrix {
for i := range m {
m[i] = v
}
return m
}
// With applies the elements of the given vectors to the corresponding positions in the matrix
func (m Matrix) With(v ...Vector) Matrix {
for i := range m {
m[i] = v[i]
}
return m
}
// Generate generates the rows of the matrix using the generator func
func (m Matrix) Generate(p int, gen VectorGenerator) Matrix {
for i := range m {
m[i] = gen(p, i)
}
return m
}
// Copy copies the matrix into a new one with the same values
// this is for cases where we want to apply mutations, but would like to leave the initial vector intact
func (m Matrix) Copy() Matrix {
n := Mat(len(m))
for i := 0; i < len(m); i++ {
n[i] = m[i].Copy()
}
return n
}
// Op applies to each of the elements a specific function
func (m Matrix) Op(transform Op) Matrix {
n := Mat(len(m))
for i := range m {
n[i] = m[i].Op(transform)
}
return n
}
// Op applies to each of the elements a specific function
func (m Matrix) Dop(transform Dop, n Matrix) Matrix {
w := Mat(len(m))
for i := range m {
w[i] = m[i].Dop(transform, n[i])
}
return w
}
// Vop applies the corresponding Vop operation to all rows, producing a Cube
func (m Matrix) Vop(dop Dop, vop Vop) Cube {
w := Cb(len(m))
for i := range m {
w[i] = m[i].Vop(dop, vop)
}
return w
}
// String prints the matrix in an easily readable form
func (m Matrix) String() string {
builder := strings.Builder{}
builder.WriteString(fmt.Sprintf("(%d)", len(m)))
builder.WriteString("\n")
for i := 0; i < len(m); i++ {
builder.WriteString("\t")
builder.WriteString(fmt.Sprintf("[%d]", i))
builder.WriteString(fmt.Sprintf("%v", m[i]))
builder.WriteString("\n")
}
return builder.String()
}
// MustHaveSize will check and make sure that the given vector is of the given size
func MustHaveDim(m Matrix, n int) {
if len(m) != n {
panic(fmt.Sprintf("matrix must have primary dimension '%v' vs '%v'", m, n))
}
} | xmath/matrix.go | 0.86785 | 0.69181 | matrix.go | starcoder |
package datamodel
import (
"fmt"
"strconv"
)
const (
TypePoint = "Point"
TypeLineString = "LineString"
TypePolygon = "Polygon"
TypeMultiPoint = "MultiPoint"
TypeMultiLineString = "MultiLineString"
TypeMultiPolygon = "MultiPolygon"
)
var MismatchTypeError = fmt.Errorf("given strings are not location type")
// Location
type Location struct {
Location interface{} `json:"location"` // "$ref": "http://geojson.org/schema/Geometry.json#"
Address Address `json:"address"`
AreaServed string `json:"areaServed"`
}
// Address
type Address struct {
StreetAddress string `json:"streetAddress"`
AddressLocality string `json:"addressLocality"`
AddressRegion string `json:"addressRegion"`
AddressCountry string `json:"addressCountry"`
PostalCode string `json:"postalCode"`
PostOfficeBoxNumber string `json:"postOfficeBoxNumber"`
}
// GenLocation returns specified LocationItem instance.
func GenLocation(typeName string) (*Location, error) {
ret := Location{
Location: nil,
Address: Address{},
AreaServed: "",
}
bbox := make([]float64, 4)
switch typeName {
case TypePoint:
ret.Location = Point{Type: TypePoint, Coordinates: make([]float64, 2), Bbox: bbox}
case TypeLineString:
ret.Location = LineString{Type: TypeLineString, Coordinates: [][]float64{make([]float64, 2), make([]float64, 2)}, Bbox: bbox}
case TypePolygon:
ret.Location = Polygon{Type: TypePolygon, Coordinates: [][][]float64{{make([]float64, 2), make([]float64, 2), make([]float64, 2), make([]float64, 2)}}, Bbox: bbox}
case TypeMultiPoint:
ret.Location = MultiPoint{Type: TypeMultiPoint, Coordinates: [][]float64{make([]float64, 2)}, Bbox: bbox}
case TypeMultiLineString:
ret.Location = MultiLineString{Type: TypeMultiLineString, Coordinates: [][][]float64{{make([]float64, 2), make([]float64, 2)}}, Bbox: bbox}
case TypeMultiPolygon:
ret.Location = MultiPolygon{Type: TypeMultiPolygon, Coordinates: [][][][]float64{{{make([]float64, 2), make([]float64, 2), make([]float64, 2), make([]float64, 2)}}}, Bbox: bbox}
default:
return nil, MismatchTypeError
}
return &ret, nil
}
////// Location interfaces ref: https://geojson.org/schema/Geometry.json
// Point is an expression of GeoJSON Point.
type Point struct {
Type string `json:"type"` // must be "Point". required.
Coordinates []float64 `json:"coordinates"` // have to hold at least 2 items. required.
Bbox []float64 `json:"bbox"` // have to hold at least 4 items. optional.
}
// LineString is an expression of GeoJSON LineString
type LineString struct {
Type string `json:"type"` // must be "LineString". required.
Coordinates [][]float64 `json:"coordinates"` // array that have to hold at least 2 array that have to hold at leaset 2 items. required.
Bbox []float64 `json:"bbox"` // have to hold at least 4 items. optional.
}
// Polygon is an expresion of GeoJSON Polygon
type Polygon struct {
Type string `json:"type"` // must be "Polygon". required.
Coordinates [][][]float64 `json:"coordinates"` // array of array that have to hold at least 4 items that holds 2 items. required.
Bbox []float64 `json:"bbox"` // have to hold at least 4 items. optional.
}
// MultiPoint is an expression of GeoJSON MultiPoint.
type MultiPoint struct {
Type string `json:"type"` // must be "MultiPoint". required.
Coordinates [][]float64 `json:"coordinates"` // array of array that have to hold at least 2 items. required.
Bbox []float64 `json:"bbox"` // have to hold at least 4 items. optional.
}
// MultiLineString is an expression of GeoJSON MultiLineString.
type MultiLineString struct {
Type string `json:"type"` // must be "MultiLineString". required.
Coordinates [][][]float64 `json:"coordinates"` // array of array that have to hold at least 2 arrays that hold at least 2 items. required.
Bbox []float64 `json:"bbox"` // have to hold at least 4 items. optional.
}
// MultiPolygon is an expression of GeoJSON MultiPolygon.
type MultiPolygon struct {
Type string `json:"type"` // must be "MultiPolygon". required.
Coordinates [][][][]float64 `json:"coordinates"` // array of array of array that have to hold at least 4 array that have to hold at least 2 items. required.
Bbox []float64 `json:"bbox"` // have to hold at least 4 items. optional.
}
// XY is an expression of the coordinate holds some [X,Y]
// This is not defined at fiware data model.
type XY struct {
X float64 `json:"x"`
Y float64 `json:"y"`
}
// String returns string expresion used by sprintf("%f").
func (xy *XY) String() string {
x := strconv.FormatFloat(xy.X, 'f', -1, 64)
y := strconv.FormatFloat(xy.Y, 'f', -1, 64)
return fmt.Sprintf("%s,%s", x, y)
}
// LatLng is an expression of the coordinate holds some [latitude, longitude]
// This is not defined at fiware data model.
type LatLng struct {
Latitude float64 `json:"latitude"`
Longitude float64 `json:"longitude"`
}
// String returns string expresion used by strconv.Ftoa64
func (ll *LatLng) String() string {
lat := strconv.FormatFloat(ll.Latitude, 'f', -1, 64)
lng := strconv.FormatFloat(ll.Longitude, 'f', -1, 64)
return fmt.Sprintf("%s,%s", lat, lng)
} | datamodel/location.go | 0.776029 | 0.445288 | location.go | starcoder |
package yuv
import (
"image"
"image/color"
)
type YCbCrSubsampleRatio int
const (
NV12 YCbCrSubsampleRatio = iota
)
type YUV struct {
Y, U, V []uint8
YStride int
CStride int
SubsampleRatio YCbCrSubsampleRatio
Rect image.Rectangle
}
func (p *YUV) ColorModel() color.Model {
return color.YCbCrModel
}
func (p *YUV) Bounds() image.Rectangle {
return p.Rect
}
func (p *YUV) At(x, y int) color.Color {
return p.YUVAt(x, y)
}
func (p *YUV) YUVAt(x, y int) color.YCbCr {
if !(image.Point{x, y}.In(p.Rect)) {
return color.YCbCr{}
}
yi := p.YOffset(x, y)
ci := p.COffset(x, y)
return color.YCbCr{
p.Y[yi],
p.U[ci],
p.V[ci],
}
}
// YOffset returns the index of the first element of Y that corresponds to
// the pixel at (x, y).
func (p *YUV) YOffset(x, y int) int {
return (y-p.Rect.Min.Y)*p.YStride + (x - p.Rect.Min.X)
}
// COffset returns the index of the first element of Cb or Cr that corresponds
// to the pixel at (x, y).
func (p *YUV) COffset(x, y int) int {
switch p.SubsampleRatio {
case NV12:
return 2 * ((y/2-p.Rect.Min.Y/2)*p.CStride + (x/2 - p.Rect.Min.X/2))
}
// Default to 4:4:4 subsampling.
return (y-p.Rect.Min.Y)*p.CStride + (x - p.Rect.Min.X)
}
// SubImage returns an image representing the portion of the image p visible
// through r. The returned value shares pixels with the original image.
func (p *YUV) SubImage(r image.Rectangle) image.Image {
r = r.Intersect(p.Rect)
// If r1 and r2 are Rectangles, r1.Intersect(r2) is not guaranteed to be inside
// either r1 or r2 if the intersection is empty. Without explicitly checking for
// this, the Pix[i:] expression below can panic.
if r.Empty() {
return &YUV{
SubsampleRatio: p.SubsampleRatio,
}
}
yi := p.YOffset(r.Min.X, r.Min.Y)
ci := p.COffset(r.Min.X, r.Min.Y)
return &YUV{
Y: p.Y[yi:],
U: p.U[ci:],
V: p.V[ci:],
SubsampleRatio: p.SubsampleRatio,
YStride: p.YStride,
CStride: p.CStride,
Rect: r,
}
}
func (p *YUV) Opaque() bool {
return true
}
func yuvSize(r image.Rectangle, subsampleRatio YCbCrSubsampleRatio) (w, h, cw, ch int) {
w, h = r.Dx(), r.Dy()
switch subsampleRatio {
case NV12:
cw = (r.Max.X+1)/2 - r.Min.X/2
ch = (r.Max.Y+1)/2 - r.Min.Y/2
default:
// Default to 4:4:4 subsampling.
cw = w
ch = h
}
return
}
// NewYCbCr returns a new YCbCr image with the given bounds and subsample
// ratio.
func NewYUV(r image.Rectangle, subsampleRatio YCbCrSubsampleRatio) *YUV {
w, h, cw, ch := yuvSize(r, subsampleRatio)
i0 := w*h + 0*cw*ch
i1 := w*h + 1*cw*ch
i2 := w*h + 2*cw*ch
b := make([]byte, i2)
return &YUV{
Y: b[:i0:i0],
U: b[i0:i1:i1],
V: b[i1:i2:i2],
SubsampleRatio: subsampleRatio,
YStride: w,
CStride: cw,
Rect: r,
}
} | vendor/github.com/shethchintan7/yuv/yuv.go | 0.826362 | 0.422862 | yuv.go | starcoder |
// parser package defines the parser and lexer for translating a *supported subset* of
// WebIDL (http://www.w3.org/TR/WebIDL/) into an AST.
package parser
import (
"fmt"
"github.com/ben-clayton/webidlparser/ast"
)
// tryConsumeIdentifier attempts to consume an expected identifier.
func (p *sourceParser) tryConsumeIdentifier() (string, bool) {
if !p.isToken(tokenTypeIdentifier) {
return "", false
}
value := p.currentToken.value
p.consumeToken()
return value, true
}
// consumeIdentifier consumes an expected identifier token or adds an error node.
func (p *sourceParser) consumeIdentifier() string {
if identifier, ok := p.tryConsumeIdentifier(); ok {
return identifier
}
p.emitError("Expected identifier, found token %v", p.currentToken)
return ""
}
func (p *sourceParser) consumeLiteral() ast.Literal {
base := &ast.Base{}
finish := p.node(base)
l, ok := p.consume(tokenTypeIdentifier, tokenTypeString, tokenTypeNumber, tokenTypeLeftBracket, tokenTypeLeftBrace)
if !ok {
p.emitError("Expected literal, found token %v", p.currentToken)
finish()
return &ast.BasicLiteral{Base: *base}
}
switch l.kind {
case tokenTypeIdentifier, tokenTypeString, tokenTypeNumber:
finish()
return &ast.BasicLiteral{Base: *base, Value: l.value}
case tokenTypeLeftBracket:
n := &ast.SequenceLiteral{}
for !p.isToken(tokenTypeRightBracket) {
if len(n.Elems) != 0 {
p.consume(tokenTypeComma)
}
if p.isToken(tokenTypeRightBracket) {
break
}
n.Elems = append(n.Elems, p.consumeLiteral())
}
// , (optional)
p.tryConsume(tokenTypeComma)
p.consume(tokenTypeRightBracket)
finish()
n.Base = *base
return n
case tokenTypeLeftBrace:
p.consume(tokenTypeRightBrace)
finish()
return &ast.DefaultDictionaryLiteral{Base: *base}
}
panic("unreachable")
}
// tryParserFn is a function that attempts to build an AST node.
type tryParserFn func() (ast.Node, bool)
// lookaheadParserFn is a function that performs lookahead.
type lookaheadParserFn func(currentToken lexeme) bool
// rightNodeConstructor is a function which takes in a left expr node and the
// token consumed for a left-recursive operator, and returns a newly constructed
// operator expression if a right expression could be found.
type rightNodeConstructor func(ast.Node, lexeme) (ast.Node, bool)
// commentedLexeme is a lexeme with comments attached.
type commentedLexeme struct {
lexeme
comments []string
}
// sourceParser holds the state of the parser.
type sourceParser struct {
startIndex bytePosition // The start index for position decoration on nodes.
lex *peekableLexer // a reference to the lexer used for tokenization
nodes nodeStack // the stack of the current nodes
currentToken commentedLexeme // the current token
previousToken commentedLexeme // the previous token
config parserConfig // Configuration for customizing the parser
}
// parserConfig holds configuration for customizing the parser
type parserConfig struct {
ignoredTokenTypes map[tokenType]struct{} // the token types ignored by the parser
}
// buildParser returns a new sourceParser instance.
func buildParser(lexer *lexer, config parserConfig, startIndex bytePosition) *sourceParser {
l := peekableLex(lexer)
newLexeme := func() commentedLexeme {
return commentedLexeme{lexeme: lexeme{tokenTypeEOF, 0, 0, ""}}
}
return &sourceParser{
startIndex: startIndex,
lex: l,
currentToken: newLexeme(),
previousToken: newLexeme(),
config: config,
}
}
// createErrorNode creates a new error node and returns it.
func (p *sourceParser) createErrorNode(format string, args ...interface{}) *ast.ErrorNode {
n := &ast.ErrorNode{Message: fmt.Sprintf(format, args...)}
p.decorateStartRuneAndComments(n, p.currentToken)
p.decorateEndRune(n, p.previousToken)
return n
}
// node creates a new node of the given type, decorates it with the current token's
// position as its start position, and pushes it onto the nodes stack.
func (p *sourceParser) node(node ast.Node) func() {
p.decorateStartRuneAndComments(node, p.currentToken)
p.nodes.push(node)
return func() {
// finishNode pops the current node from the top of the stack and decorates it with
// the current token's end position as its end position.
if p.currentNode() == nil {
panic(fmt.Sprintf("No current node on stack. Token: %s", p.currentToken.value))
}
p.decorateEndRune(p.currentNode(), p.previousToken)
p.nodes.pop()
}
}
// decorateStartRuneAndComments decorates the given node with the location of the given token as its
// starting rune, as well as any comments attached to the token.
func (p *sourceParser) decorateStartRuneAndComments(node ast.Node, token commentedLexeme) {
b := node.NodeBase()
b.Start = int(token.position) + int(p.startIndex)
b.Line = int(token.line)
p.decorateComments(node, token.comments)
}
// decorateComments decorates the given node with the specified comments.
func (p *sourceParser) decorateComments(node ast.Node, comments []string) {
b := node.NodeBase()
b.Comments = append(b.Comments, comments...)
}
// decorateEndRune decorates the given node with the location of the given token as its
// ending rune.
func (p *sourceParser) decorateEndRune(node ast.Node, token commentedLexeme) {
node.NodeBase().End = int(token.position) + len(token.value) - 1 + int(p.startIndex)
}
// currentNode returns the node at the top of the stack.
func (p *sourceParser) currentNode() ast.Node {
return p.nodes.topValue()
}
// consumeToken advances the lexer forward, returning the next token.
func (p *sourceParser) consumeToken() commentedLexeme {
var comments = make([]string, 0)
for {
token := p.lex.nextToken()
if token.kind == tokenTypeComment {
comments = append(comments, token.value)
}
if _, ok := p.config.ignoredTokenTypes[token.kind]; !ok {
p.previousToken = p.currentToken
p.currentToken = commentedLexeme{token, comments}
return p.currentToken
}
}
}
// isToken returns true if the current token matches one of the types given.
func (p *sourceParser) isToken(types ...tokenType) bool {
for _, kind := range types {
if p.currentToken.kind == kind {
return true
}
}
return false
}
// nextToken returns the next token found, without advancing the parser. Used for
// lookahead.
func (p *sourceParser) nextToken() lexeme {
for i := 0; i < 1000; i++ {
token := p.lex.peekToken(i + 1)
if _, ok := p.config.ignoredTokenTypes[token.kind]; !ok {
return token
}
}
panic("stale")
}
// isNextToken returns true if the *next* token matches one of the types given.
func (p *sourceParser) isNextToken(types ...tokenType) bool {
token := p.nextToken()
for _, kind := range types {
if token.kind == kind {
return true
}
}
return false
}
func (p *sourceParser) isIdentifier(name string) bool {
return p.isToken(tokenTypeIdentifier) && p.currentToken.value == name
}
// isNextIdentifier returns true if the next token is a keyword matching that given.
func (p *sourceParser) isNextIdentifier(keyword string) bool {
token := p.nextToken()
return token.kind == tokenTypeIdentifier && token.value == keyword
}
// emitError creates a new error node and attachs it as a child of the current
// node.
func (p *sourceParser) emitError(format string, args ...interface{}) {
errorNode := p.createErrorNode(format, args...)
b := p.currentNode().NodeBase()
b.Errors = append(b.Errors, errorNode)
}
// consumeKeyword consumes an expected keyword token or adds an error node.
func (p *sourceParser) consumeKeyword(keyword string) bool {
if !p.tryConsumeKeyword(keyword) {
p.emitError("Expected keyword %s, found token %v", keyword, p.currentToken)
return false
}
return true
}
// tryConsumeKeyword attempts to consume an expected keyword token.
func (p *sourceParser) tryConsumeKeyword(keyword string) bool {
if !p.isIdentifier(keyword) {
return false
}
p.consumeToken()
return true
}
// consume performs consumption of the next token if it matches any of the given
// types and returns it. If no matching type is found, adds an error node.
func (p *sourceParser) consume(types ...tokenType) (lexeme, bool) {
token, ok := p.tryConsume(types...)
if !ok {
p.emitError("Expected one of: %v, found: %v", types, p.currentToken)
}
return token, ok
}
// tryConsume performs consumption of the next token if it matches any of the given
// types and returns it.
func (p *sourceParser) tryConsume(types ...tokenType) (lexeme, bool) {
token, found := p.tryConsumeWithComments(types...)
return token.lexeme, found
}
// tryConsume performs consumption of the next token if it matches any of the given
// types and returns it.
func (p *sourceParser) tryConsumeWithComments(types ...tokenType) (commentedLexeme, bool) {
if p.isToken(types...) {
token := p.currentToken
p.consumeToken()
return token, true
}
return commentedLexeme{lexeme{tokenTypeError, -1, -1, ""}, make([]string, 0)}, false
}
// consumeUntil consumes all tokens until one of the given token types is found.
func (p *sourceParser) consumeUntil(types ...tokenType) lexeme {
for {
found, ok := p.tryConsume(types...)
if ok {
return found
}
p.consumeToken()
}
}
// oneOf runs each of the sub parser functions, in order, until one returns true. Otherwise
// returns nil and false.
func (p *sourceParser) oneOf(subParsers ...tryParserFn) (ast.Node, bool) {
for _, subParser := range subParsers {
node, ok := subParser()
if ok {
return node, ok
}
}
return nil, false
}
// performLeftRecursiveParsing performs left-recursive parsing of a set of operators. This method
// first performs the parsing via the subTryExprFn and then checks for one of the left-recursive
// operator token types found. If none found, the left expression is returned. Otherwise, the
// rightNodeBuilder is called to attempt to construct an operator expression. This method also
// properly handles decoration of the nodes with their proper start and end run locations.
func (p *sourceParser) performLeftRecursiveParsing(subTryExprFn tryParserFn, rightNodeBuilder rightNodeConstructor, rightTokenTester lookaheadParserFn, operatorTokens ...tokenType) (ast.Node, bool) {
var currentLeftToken commentedLexeme
currentLeftToken = p.currentToken
// Consume the left side of the expression.
leftNode, ok := subTryExprFn()
if !ok {
return nil, false
}
// Check for an operator token. If none found, then we've found just the left side of the
// expression and so we return that node.
if !p.isToken(operatorTokens...) {
return leftNode, true
}
// Keep consuming pairs of operators and child expressions until such
// time as no more can be consumed. We use this loop+custom build rather than recursion
// because these operators are *left* recursive, not right.
var currentLeftNode ast.Node
currentLeftNode = leftNode
for {
// Check for an operator.
if !p.isToken(operatorTokens...) {
break
}
// If a lookahead function is defined, check the lookahead for the matched token.
if rightTokenTester != nil && !rightTokenTester(p.currentToken.lexeme) {
break
}
// Consume the operator.
operatorToken, ok := p.tryConsumeWithComments(operatorTokens...)
if !ok {
break
}
// Consume the right hand expression and build an expression node (if applicable).
exprNode, ok := rightNodeBuilder(currentLeftNode, operatorToken.lexeme)
if !ok {
p.emitError("Expected right hand expression, found: %v", p.currentToken)
return currentLeftNode, true
}
p.decorateStartRuneAndComments(exprNode, currentLeftToken)
p.decorateEndRune(exprNode, p.previousToken)
currentLeftNode = exprNode
currentLeftToken = operatorToken
}
return currentLeftNode, true
} | parser/parser.go | 0.751648 | 0.529932 | parser.go | starcoder |
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
func IB(root *TreeNode, sum int, found bool) bool {
if (found) {
return found
}
if root == nil {return false}
if root.Left == nil && root.Right == nil {
x := sum - root.Val
return x == 0
}
found = IB(root.Left, sum - root.Val, found)
if !found {
found = IB(root.Right, sum - root.Val, found)
}
return found
}
func hasPathSum(root *TreeNode, sum int) bool {
return IB(root, sum, false)
}
/*
Given a binary tree and a sum, find all root-to-leaf paths where each path's sum equals the given sum.
Note: A leaf is a node with no children.
Example:
Given the below binary tree and sum = 22,
5
/ \
4 8
/ / \
11 13 4
/ \ / \
7 2 5 1
Return:
[
[5,4,11,2],
[5,8,4,5]
]
*/
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
func IB(root *TreeNode, sum int, tmp []int, r [][]int) [][]int {
if root == nil {return r}
tmp = append(tmp, root.Val)
if root.Left == nil && root.Right == nil {
x := sum - root.Val
if x == 0 {
r = append(r, append([]int(nil), tmp...))
}
return r
}
r = IB(root.Left, sum - root.Val, tmp, r)
r = IB(root.Right, sum - root.Val, tmp, r)
return r
}
func pathSum(root *TreeNode, sum int) (r [][]int) {
r = IB(root, sum,[]int{}, r)
//fmt.Println(r)
return r
}
/*
Path Sum 3
You are given a binary tree in which each node contains an integer value.
Find the number of paths that sum to a given value.
The path does not need to start or end at the root or a leaf, but it must go downwards (traveling only from parent nodes to child nodes).
The tree has no more than 1,000 nodes and the values are in the range -1,000,000 to 1,000,000.
Example:
root = [10,5,-3,3,2,null,11,3,-2,null,1], sum = 8
10
/ \
5 -3
/ \ \
3 2 11
/ \ \
3 -2 1
Return 3. The paths that sum to 8 are:
1. 5 -> 3
2. 5 -> 2 -> 1
3. -3 -> 11
*/
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
func IB(root *TreeNode, sum int,r int) int {
if root == nil {return r}
//fmt.Println(acc == root.Val, root, sum, acc, r)
if (sum == root.Val) {
r++
}
r = IB(root.Left, sum - root.Val, r)
r = IB(root.Right, sum - root.Val, r)
return r
}
func pathSum(root *TreeNode, sum int) int {
r := IB(root, sum, 0)
if root == nil {
return r
}
if root.Left != nil{
r += pathSum(root.Left, sum)
}
if root.Right != nil{
r += pathSum(root.Right, sum)
}
return r
} | submissions/Path_Sum_All.go | 0.809577 | 0.44571 | Path_Sum_All.go | starcoder |
package validation
import (
"fmt"
"reflect"
"sort"
)
// Constraints is simply a collection of many constraints. All of the constraints will be run, and
// their results will be aggregated and returned.
type Constraints []Constraint
// Violations ...
func (cc Constraints) Violations(ctx Context) []ConstraintViolation {
var violations []ConstraintViolation
for _, c := range cc {
violations = append(violations, c.Violations(ctx)...)
}
sort.Slice(violations, func(i, j int) bool {
return violations[i].Path < violations[j].Path
})
return violations
}
// Elements is a Constraint used to validate every value (element) in an array, a map, or a slice.
type Elements []Constraint
// Violations ...
func (e Elements) Violations(ctx Context) []ConstraintViolation {
rval := UnwrapValue(ctx.Value().Node)
rtyp := UnwrapType(rval.Type())
if rval.IsZero() {
return nil
}
allowed := []reflect.Kind{reflect.Array, reflect.Map, reflect.Slice}
violations := ShouldBe(ctx, rtyp, allowed...)
if len(violations) > 0 {
return violations
}
if rval.Len() == 0 {
return nil
}
for _, constraint := range e {
switch rval.Kind() {
case reflect.Map:
iter := rval.MapRange()
for iter.Next() {
key := iter.Key()
value := iter.Value()
ctx := ctx.WithValue(valueString(key), value)
violations = append(violations, constraint.Violations(ctx)...)
}
case reflect.Array, reflect.Slice:
for i := 0; i < rval.Len(); i++ {
ctx := ctx.WithValue(fmt.Sprintf("[%d]", i), rval.Index(i))
violations = append(violations, constraint.Violations(ctx)...)
}
}
}
return violations
}
// Fields is a Constraint used to validate the values of specific fields on a struct.
type Fields map[string]Constraint
// Violations ...
func (f Fields) Violations(ctx Context) []ConstraintViolation {
rval := UnwrapValue(ctx.Value().Node)
rtyp := UnwrapType(rval.Type())
if IsNillable(rval) && rval.IsNil() {
return nil
}
violations := ShouldBe(ctx, rtyp, reflect.Struct)
if len(violations) > 0 {
return violations
}
for fieldName, constraint := range f {
ctx := ctx.WithValue(FieldName(ctx, fieldName), rval.FieldByName(fieldName))
violations = append(violations, constraint.Violations(ctx)...)
}
return violations
}
// Keys is a Constraint used to validate the keys of a map.
type Keys []Constraint
// Violations ...
func (k Keys) Violations(ctx Context) []ConstraintViolation {
rval := UnwrapValue(ctx.Value().Node)
rtyp := UnwrapType(rval.Type())
if rval.IsZero() {
return nil
}
violations := ShouldBe(ctx, rtyp, reflect.Map)
if len(violations) > 0 {
return violations
}
if rval.Len() == 0 {
return nil
}
for _, constraint := range k {
for _, key := range rval.MapKeys() {
ctx := ctx.WithValue(valueString(key), key).WithPathKind(PathKindKey)
violations = append(violations, constraint.Violations(ctx)...)
}
}
return violations
}
// Lazy is a Constraint that allows a function that returns Constraints to be evaluated at
// validation-time. This enables things like defining constraints for recursive structures.
type Lazy func() Constraint
// Violations ...
func (f Lazy) Violations(ctx Context) []ConstraintViolation {
return f().Violations(ctx)
}
// LazyDynamic is a Constraint that's extremely similar to Lazy, and fulfils mostly the same
// purpose, but instead expects a function that has a single argument of the type being validated.
func LazyDynamic(constraintFn interface{}) Constraint {
// TODO: Check constraintFn is not nil?
return &lazyDynamic{
constraintFn: constraintFn,
}
}
// lazyDynamic is the implementation of the LazyDynamic constraint.
type lazyDynamic struct {
constraintFn interface{}
}
// constraintType is kept on it's own here because it won't change, we don't need to fetch it every
// time a constraint is run that uses it.
var constraintType = reflect.TypeOf((*Constraint)(nil)).Elem()
// Violations ...
func (ld *lazyDynamic) Violations(ctx Context) []ConstraintViolation {
rval := UnwrapValue(ctx.Value().Node)
if !rval.IsValid() || (IsNillable(rval) && rval.IsNil()) {
return nil
}
rtyp := UnwrapType(rval.Type())
violations := ShouldBe(ctx, rtyp, reflect.Struct)
if len(violations) > 0 {
return violations
}
rfn := reflect.ValueOf(ld.constraintFn)
rfnt := rfn.Type()
if rfnt.NumIn() != 1 {
panic("validation: LazyDynamic expects a function that accepts a single argument of the type being validated (or it's unwrapped value type)")
}
if rfnt.NumOut() != 1 || rfnt.Out(0) != constraintType {
panic("validation: LazyDynamic expects a function that returns a Constraint")
}
isContextType := rfnt.In(0) == ctx.Value().Node.Type()
isUnwrappedType := rfnt.In(0) == rval.Type()
if !isContextType && !isUnwrappedType {
panic("validation: LazyDynamic expects a function that accepts a single argument of the type being validated (or it's unwrapped value type)")
}
var constraint Constraint
if isUnwrappedType {
constraint = rfn.Call([]reflect.Value{rval})[0].Interface().(Constraint)
} else {
constraint = rfn.Call([]reflect.Value{ctx.Value().Node})[0].Interface().(Constraint)
}
return constraint.Violations(ctx)
}
// Map is a Constraint used to validate a map. This Constraint validates the values in the map, by
// specific keys. If you want to use the same validation on all keys of a map, use Elements instead.
// If you want to validate the keys of the map, use Keys instead.
type Map map[interface{}]Constraint
// Violations ...
func (m Map) Violations(ctx Context) []ConstraintViolation {
rval := UnwrapValue(ctx.Value().Node)
rtyp := UnwrapType(rval.Type())
if rval.IsZero() {
return nil
}
violations := ShouldBe(ctx, rtyp, reflect.Map)
if len(violations) > 0 {
return violations
}
for mapKey, constraint := range m {
value := rval.MapIndex(reflect.ValueOf(mapKey))
if IsEmpty(value) {
continue
}
ctx := ctx.WithValue(
valueString(reflect.ValueOf(mapKey)),
value,
)
violations = append(violations, constraint.Violations(ctx)...)
}
return violations
}
// When conditionally runs some constraints. The predicate is set up at the time of creating the
// constraints. If you want a more dynamic approach, you should use WhenFn instead. You can also
// build up constraints programmatically and use the value being validated to build the constraints.
func When(predicate bool, constraints ...Constraint) ConstraintFunc {
return func(ctx Context) []ConstraintViolation {
var violations []ConstraintViolation
if predicate {
for _, c := range constraints {
violations = append(violations, c.Violations(ctx)...)
}
}
return violations
}
}
// WhenFn lazily conditionally runs some constraints. The predicate function is called during the
// validation process. If you need an even more dynamic approach, you can also build up constraints
// programmatically and use the value being validated to build the constraints.
func WhenFn(predicateFn func(ctx Context) bool, constraints ...Constraint) ConstraintFunc {
return func(ctx Context) []ConstraintViolation {
var violations []ConstraintViolation
if predicateFn(ctx) {
for _, c := range constraints {
violations = append(violations, c.Violations(ctx)...)
}
}
return violations
}
}
// valueString returns a string representation of the given value. It handles any type that may be
// nil by returning "nil", otherwise defers to fmt.Sprint.
func valueString(val reflect.Value) string {
unwrapped := UnwrapValue(val)
if IsNillable(unwrapped) && unwrapped.IsNil() {
return "nil"
}
return fmt.Sprint(unwrapped)
} | constraints.go | 0.73431 | 0.416856 | constraints.go | starcoder |
package record
import (
"fmt"
)
// A Record represents a group of fields.
type Record interface {
// Iterate goes through all the fields of the record and calls the given function by passing each one of them.
// If the given function returns an error, the iteration stops.
Iterate(fn func(Field) error) error
// GetField returns a field by name.
GetField(name string) (Field, error)
}
// A Keyer returns the key identifying records in their storage.
// This is usually implemented by records read from storages.
type Keyer interface {
Key() []byte
}
// A Scanner can iterate over a record and scan all the fields.
type Scanner interface {
ScanRecord(Record) error
}
// FieldBuffer is slice of fields which implements the Record interface.
type FieldBuffer []Field
// NewFieldBuffer creates a FieldBuffer with the given fields.
func NewFieldBuffer(fields ...Field) FieldBuffer {
return FieldBuffer(fields)
}
// Add a field to the buffer.
func (fb *FieldBuffer) Add(f Field) {
*fb = append(*fb, f)
}
// ScanRecord copies all the fields of r to the buffer.
func (fb *FieldBuffer) ScanRecord(r Record) error {
return r.Iterate(func(f Field) error {
*fb = append(*fb, f)
return nil
})
}
// GetField returns a field by name. Returns an error if the field doesn't exists.
func (fb FieldBuffer) GetField(name string) (Field, error) {
for _, f := range fb {
if f.Name == name {
return f, nil
}
}
return Field{}, fmt.Errorf("field %q not found", name)
}
// Set replaces a field if it already exists or creates one if not.
func (fb *FieldBuffer) Set(f Field) {
s := *fb
for i := range s {
if s[i].Name == f.Name {
(*fb)[i] = f
return
}
}
fb.Add(f)
}
// Iterate goes through all the fields of the record and calls the given function by passing each one of them.
// If the given function returns an error, the iteration stops.
func (fb FieldBuffer) Iterate(fn func(Field) error) error {
for _, f := range fb {
err := fn(f)
if err != nil {
return err
}
}
return nil
}
// Delete a field from the buffer.
func (fb *FieldBuffer) Delete(name string) error {
s := *fb
for i := range s {
if s[i].Name == name {
*fb = append(s[0:i], s[i+1:]...)
return nil
}
}
return fmt.Errorf("field %q not found", name)
}
// Replace the field with the given name by f.
func (fb *FieldBuffer) Replace(name string, f Field) error {
s := *fb
for i := range s {
if s[i].Name == name {
s[i] = f
*fb = s
return nil
}
}
return fmt.Errorf("field %q not found", f.Name)
}
// NewFromMap creates a record from a map.
// Due to the way maps are designed, iteration order is not guaranteed.
func NewFromMap(m map[string]interface{}) Record {
return mapRecord(m)
}
type mapRecord map[string]interface{}
var _ Record = (*mapRecord)(nil)
func (m mapRecord) Iterate(fn func(Field) error) error {
for k, v := range m {
if v == nil {
continue
}
f, err := NewField(k, v)
if err != nil {
return err
}
err = fn(f)
if err != nil {
return err
}
}
return nil
}
func (m mapRecord) GetField(name string) (Field, error) {
v, ok := m[name]
if !ok {
return Field{}, fmt.Errorf("field %q not found", name)
}
return NewField(name, v)
} | record/record.go | 0.771801 | 0.435361 | record.go | starcoder |
package nvm
import "math"
var (
_v *V
_ Vector = _v
)
// V represents a vector.
type V struct {
Data []float64
}
// NewV creates a new vector of dimension `d`. NewV will panic if `d <= 0`.
func NewV(d int) *V {
if d <= 0 {
panic(ErrDim)
}
return &V{Data: make([]float64, d)}
}
// NewVShare creates a new vector of dimension `len(data)`. NewVShare will panic if `len(data) == 0`.
// Note: Slice both `V.Data` and 'data' share a same underlying array.
func NewVShare(data []float64) *V {
if len(data) == 0 {
panic(ErrDim)
}
return &V{Data: data}
}
// NewVCopy creates a new vector of dimension `len(data)`. NewVCopy will panic if `len(data) == 0`.
func NewVCopy(data []float64) *V {
d := len(data)
if d == 0 {
panic(ErrDim)
}
newData := make([]float64, d)
copy(newData, data)
return &V{Data: newData}
}
// IsNaV reports whether `v` is "Not-a-Vector".
func (v *V) IsNaV() bool {
if len(v.Data) == 0 {
return true
}
return false
}
// Dim returns the dimension of vector.
func (v *V) Dim() int {
return len(v.Data)
}
// At returns the element at position `i`. At will panic if `i` is out of bounds.
func (v *V) At(i int) float64 {
if i < 0 || i >= v.Dim() {
panic(ErrIndex)
}
return v.Data[i]
}
// SetAt sets `f` to the element at position `i`. SetAt will panic if `i` is out of bounds.
func (v *V) SetAt(i int, f float64) Vector {
if i < 0 || i >= v.Dim() {
panic(ErrIndex)
}
v.Data[i] = f
return v
}
// NormL0 returns L0 norm. L0 norm equals the number of non-zero (include NaN/Inf) elements in the vector.
func (v *V) NormL0() int {
var c int
for _, e := range v.Data {
if !IsNEqual(e, 0) {
c++
}
}
return c
}
// NormL1 returns L1 norm (Manhattan distance). i.e. `\sum_{i=0}^n{|x_i|}`.
func (v *V) NormL1() float64 {
if v.IsNaV() {
panic(ErrNaV)
}
var n float64
for _, e := range v.Data {
n += math.Abs(e)
}
return n
}
// NormL2 returns L2 norm (Euclidean distance). i.e. `\sqrt{\sum_{i=0}^n{x_i^2}}`.
func (v *V) NormL2() float64 {
if v.IsNaV() {
panic(ErrNaV)
}
var n float64
for _, e := range v.Data {
n += e * e
}
return math.Sqrt(n)
}
// Unit returns the unit vector.
func (v *V) Unit() Vector {
if v.IsNaV() {
panic(ErrNaV)
}
norm := v.NormL2()
rv := NewV(v.Dim())
for i, e := range v.Data {
rv.Data[i] = e / norm
}
return rv
}
// Scale scales the vector by `f`.
func (v *V) Scale(f float64) Vector {
if IsNaN(f) {
panic(ErrNaN)
}
for i, e := range v.Data {
v.Data[i] = f * e
}
return v
}
// IsZero reports whether the vector is zero vector, the every element is zero.
func (v *V) IsZero() bool {
if v.IsNaV() {
panic(ErrNaV)
}
for _, e := range v.Data {
if !IsNEqual(e, 0) {
return false
}
}
return true
}
// Max returns the maximum value `f` and the first found index `idx` in the vector.
// `NaN, -1` will be returned if the vector is not normal.
func (v *V) Max() (f float64, idx int) {
if v.IsNaV() {
panic(ErrNaV)
}
f = NaN()
idx = -1
for i, e := range v.Data {
if e > f || IsNaN(f) { /*NaN与任何float64比较大小的结果是false*/
f = e
idx = i
}
}
if IsNaN(f) {
idx = -1
return
}
return f, idx
}
// Min returns the minimum value `f` and the first found index `idx` in the vector `v`.
// `NaN, -1` will be returned if the vector is not normal.
func (v *V) Min() (f float64, idx int) {
if v.IsNaV() {
panic(ErrNaV)
}
f = NaN()
idx = -1
for i, e := range v.Data {
if e < f || IsNaN(f) {
f = e
idx = i
}
}
if IsNaN(f) {
idx = -1
return
}
return f, idx
}
// MaxAbs returns the maximum absolute value `f` and the first found index `idx` in the vector `v`.
// It is also known as special case of infinity norm, i.e. `\max(|x_1|,|x_2|,...,|x_n|)`.
// `NaN, -1` will be returned if the vector is not normal.
func (v *V) MaxAbs() (f float64, idx int) {
if v.IsNaV() {
panic(ErrNaV)
}
f = NaN()
idx = -1
for i, e := range v.Data {
abs := math.Abs(e)
if abs > f || IsNaN(f) {
f = abs
idx = i
}
}
if IsNaN(f) {
idx = -1
return
}
return f, idx
}
// MinAbs returns the minimum absolute value `f` and the first found index `idx` in the vector `v`.
// i.e. `\min(|x_1|,|x_2|,...,|x_n|)`.
// `NaN, -1` will be returned if the vector is not normal.
func (v *V) MinAbs() (f float64, idx int) {
if v.IsNaV() {
panic(ErrNaV)
}
f = NaN()
idx = -1
for i, e := range v.Data {
abs := math.Abs(e)
if abs < f || IsNaN(f) {
f = abs
idx = i
}
}
if IsNaN(f) {
idx = -1
return
}
return f, idx
}
// Add adds the vector `x` to `v`.
func (v *V) Add(x *V) *V {
if !IsVSameShape(x, v) {
panic(ErrShape)
}
for i, e := range x.Data {
v.Data[i] += e
}
return v
}
// Sub subtracts the vector `x` from `v`.
func (v *V) Sub(x *V) *V {
if !IsVSameShape(x, v) {
panic(ErrShape)
}
for i, e := range x.Data {
v.Data[i] -= e
}
return v
}
// VCross returns the cross product of `x` cross `y` in three-dimensional space.
func VCross(x, y *V) *V {
if x.Dim() != 3 || y.Dim() != 3 {
panic(ErrShape)
}
v := NewV(3)
v.SetAt(0, x.At(1)*y.At(2)-x.At(2)*y.At(1))
v.SetAt(1, x.At(2)*y.At(0)-x.At(0)*y.At(2))
v.SetAt(2, x.At(0)*y.At(1)-x.At(1)*y.At(0))
return v
} | nvm/vector_dense.go | 0.851058 | 0.506469 | vector_dense.go | starcoder |
package diff
import (
"bytes"
)
// Comparable interface
type Comparable interface {
// Hash for comparison
Hash() []byte
}
// LCS computes the lcs of x and y
func LCS(x, y []Comparable) []Comparable {
x, y = sort(x, y)
x, y, prefix, suffix := scaleDown(x, y)
c := lcsTable(x, y)
return append(append(
prefix,
lcsFromTable(c, x, y, len(x)-1, len(y)-1)...),
suffix...,
)
}
// If the beginning and ending are equal they must be in the LCS.
// This function scales down the problem via the first property:
// https://en.wikipedia.org/wiki/Longest_common_subsequence_problem#First_property
func scaleDown(x, y []Comparable) (xs, ys, p, s []Comparable) {
p, s = []Comparable{}, []Comparable{}
for i := 0; i < len(x); i++ {
if equal(x[i], y[i]) {
p = append(p, x[i])
} else {
break
}
}
x, y = x[len(p):], y[len(p):]
for i, j := len(x)-1, len(y)-1; i >= 0 && j >= 0; {
if equal(x[i], y[j]) {
s = append([]Comparable{x[i]}, s...)
} else {
break
}
i--
j--
}
xs, ys = x[:len(x)-len(s)], y[:len(y)-len(s)]
return
}
func sort(x, y []Comparable) (small, large []Comparable) {
for i, j := 0, 0; i < len(x) && j < len(y); {
xh, yh := x[i].Hash(), y[j].Hash()
if bytes.Compare(xh[:], yh[:]) > 0 {
return y, x
}
i++
j++
}
return x, y
}
// Computes the lcs table for x and y. Time complexity is O(w*h)
func lcsTable(x, y []Comparable) [][]int {
w := len(x)
h := len(y)
c := make([][]int, w)
for i := 0; i < w; i++ {
row := make([]int, h)
for j := 0; j < h; j++ {
var top, left int
if i != 0 {
top = c[i-1][j]
}
if j != 0 {
left = row[j-1]
}
maxAdjoin := max(top, left)
if equal(x[i], y[j]) {
row[j] = maxAdjoin + 1
} else {
row[j] = maxAdjoin
}
}
c[i] = row
}
return c
}
// Backtrack the longest common subsequence for x and y via table c.
func lcsFromTable(c [][]int, x, y []Comparable, i, j int) []Comparable {
if i < 0 || j < 0 {
return []Comparable{}
}
if equal(x[i], y[j]) {
return append(lcsFromTable(c, x, y, i-1, j-1), x[i])
}
var top, left int
if i != 0 {
top = c[i-1][j]
}
if j != 0 {
left = c[i][j-1]
}
if top > left {
return lcsFromTable(c, x, y, i-1, j)
}
return lcsFromTable(c, x, y, i, j-1)
}
func equal(x, y Comparable) bool {
return bytes.Equal(x.Hash(), y.Hash())
}
func max(x, y int) int {
if x < y {
return y
}
return x
} | lib/diff/lcs.go | 0.754282 | 0.489076 | lcs.go | starcoder |
package magnets
import (
"github.com/erikbryant/magnets/common"
)
// exceedsColLimits returns true if this row has exceeded the
// legal positive/negative count for this column, false otherwise.
func (game *Game) exceedsColLimits(col int) bool {
if game.Guess.CountCol(col, common.Positive) > game.CountCol(col, common.Positive) {
return true
}
if game.Guess.CountCol(col, common.Negative) > game.CountCol(col, common.Negative) {
return true
}
if game.Guess.CountCol(col, common.Neutral)+game.Guess.CountCol(col, common.Wall) > game.CountCol(col, common.Neutral) {
return true
}
return false
}
// exceedsRowLimits returns true if this row has exceeded the
// legal positive/negative count for this row, false otherwise.
func (game *Game) exceedsRowLimits(row int) bool {
if game.Guess.CountRow(row, common.Positive) > game.CountRow(row, common.Positive) {
return true
}
if game.Guess.CountRow(row, common.Negative) > game.CountRow(row, common.Negative) {
return true
}
if game.Guess.CountRow(row, common.Neutral)+game.Guess.CountRow(row, common.Wall) > game.CountRow(row, common.Neutral) {
return true
}
return false
}
// blankCell sets the cell and its other end to be empty.
func (game *Game) blankCell(row, col int) {
rowEnd, colEnd := game.GetFrameEnd(row, col)
game.Guess.Set(row, col, common.Empty, false)
game.Guess.Set(rowEnd, colEnd, common.Empty, false)
}
// setCell attempts to set the given cell (and its other end). If it is a legal move
// it sets the cells and returns true, false otherwise.
func (game *Game) setCell(row, col int, r rune) bool {
rowEnd, colEnd := game.GetFrameEnd(row, col)
// Should we be concerned about the polarity of the neighbors?
if common.Negate(r) != r {
if game.Guess.Get(row-1, col, false) == r {
return false
}
if game.Guess.Get(row, col-1, false) == r {
return false
}
// There is an optimization to also check the other end
// of the frame to see if it would be an invalid placement.
if row == rowEnd {
if game.Guess.Get(rowEnd-1, colEnd, false) == common.Negate(r) {
return false
}
}
}
game.Guess.Set(row, col, r, false)
game.Guess.Set(rowEnd, colEnd, common.Negate(r), false)
// If this was an invalid move, undo it.
if game.exceedsRowLimits(row) || game.exceedsColLimits(col) {
game.blankCell(row, col)
return false
}
return true
}
// CountSolutions returns the total number of valid solutions for the given game.
func (game *Game) CountSolutions(row, col int) int {
solutions := 0
for {
if col >= game.Guess.Width() {
col = 0
row++
}
if row >= game.Guess.Height() {
if game.Valid() && game.Solved() {
solutions++
}
return solutions
}
if game.frames.Get(row, col, false) == common.Up || game.frames.Get(row, col, false) == common.Left {
break
}
col++
}
if game.setCell(row, col, common.Positive) {
solutions += game.CountSolutions(row, col+1)
}
if game.setCell(row, col, common.Negative) {
solutions += game.CountSolutions(row, col+1)
}
if game.setCell(row, col, common.Neutral) {
solutions += game.CountSolutions(row, col+1)
}
game.blankCell(row, col)
return solutions
}
// singleSolution returns true if there is only one solution for the game, false otherwise.
func (game *Game) singleSolution() bool {
return game.CountSolutions(0, 0) == 1
} | magnets/backtrackSolver.go | 0.828245 | 0.437163 | backtrackSolver.go | starcoder |
package main
import (
"flag"
"fmt"
"image"
"image/color"
_ "image/gif"
_ "image/jpeg"
"image/png"
"log"
"math"
"math/rand"
"os"
"strings"
)
// color_diff_euklid is a function to calculate the distance between to colors.
// The parameters are a: a RGB-array with 16bit color values and b: a RGB-array with 8bit color values.
// It returns the euklidian distance between the colors.
func color_diff_euklid(a [3]int, b []int) int {
return int(math.Sqrt(math.Pow(float64((a[0]>>8)-b[0]), 2) + math.Pow(float64((a[1]>>8)-b[1]), 2) + math.Pow(float64((a[2]>>8)-b[2]), 2)))
}
// assign_k is a function to assign each pixel of the image to one k.
// Since it is to be run multithreaded, the result is returned via a channeldoc: symbol img2color is not a type in package main installed in "."
// The start and stop of the assigned pixels are returned in the last field of the result matrix tmp_mat
// This is done to achieve deterministic results
func assign_k(image image.Image, k int, k_med [][]int, start int, stop int, ch chan [][]int) {
tmp_mat := make([][]int, stop-start+1)
for i := 0; i < len(tmp_mat); i++ {
tmp_mat[i] = make([]int, image.Bounds().Max.Y)
}
for x := start; x < stop; x++ {
for y := 0; y < (image).Bounds().Max.Y; y++ {
minimum := k
difference := 766
for i := 0; i < k; i++ {
R, G, B, _ := image.At(x, y).RGBA()
new_diff := color_diff_euklid([3]int{int(R), int(G), int(B)}, k_med[i])
if new_diff < difference {
difference = new_diff
minimum = i
}
}
tmp_mat[x-start][y] = minimum
}
}
tmp_mat[len(tmp_mat)-1][0] = start
tmp_mat[len(tmp_mat)-1][1] = stop
ch <- tmp_mat
}
// medium_k is used to calculate the medium color of all pixels that are assigned to one k
// It is used multithraded and the color is returned via a channel
func medium_k(image image.Image, j int, width int, height int, k_mat [][]int, ch_m chan []int) {
k_m := make([]int, 4)
count := 0
for x := 0; x < width; x++ {
for y := 0; y < height; y++ {
if k_mat[x][y] == j {
count++
r, g, b, _ := image.At(x, y).RGBA()
k_m[0] += int(r) >> 8
k_m[1] += int(g) >> 8
k_m[2] += int(b) >> 8
}
}
}
if count > 0 {
k_m[0] /= count
k_m[1] /= count
k_m[2] /= count
}
k_m[3] = j
ch_m <- k_m
}
// kmeans is the function to calculate k mean colors
// image is the image to be processed
// k is the number of mean colors to be calculated
// t is the number of threads to be used
// n is the number of rounds the algorithm shall run. higher n achieves better results, but from a certain n up the mean colors will not change anymore
func kmeans(image image.Image, k int, t int, n int) [][]int {
ch := make(chan [][]int)
ch_m := make(chan []int)
k_med := make([][]int, k)
r, _, _, _ := image.At(0, 0).RGBA()
rand.Seed(int64(r >> 8))
for i := 0; i < k; i++ {
R, G, B, _ := image.At(int(rand.Int31n(int32(image.Bounds().Max.X))), int(rand.Int31n(int32(image.Bounds().Max.Y)))).RGBA()
k_med[i] = []int{int(R) >> 8, int(G) >> 8, int(B) >> 8}
}
k_mat := make([][]int, image.Bounds().Max.X)
for i := 0; i < len(k_mat); i++ {
k_mat[i] = make([]int, image.Bounds().Max.Y)
}
for i := 0; i < n; i++ {
for j := 0; j < t; j++ {
start := int(math.Round(float64(j) * float64(image.Bounds().Max.X) / float64(t)))
stop := int(math.Round((float64(j) + 1) * float64(image.Bounds().Max.X) / float64(t)))
go assign_k(image, k, k_med, start, stop, ch)
}
for j := 0; j < t; j++ {
re := <-ch
copy(k_mat[re[len(re)-1][0]:re[len(re)-1][1]], re[0:len(re)-1])
}
for j := 0; j < k; j++ {
go medium_k(image, j, image.Bounds().Max.X, image.Bounds().Max.Y, k_mat, ch_m)
}
for j := 0; j < k; j++ {
k_m := <-ch_m
k_med[k_m[3]] = k_m[:3]
}
fmt.Printf("\rProcessing:\t%.2f%%", (float64(i)*100)/float64(n))
}
fmt.Printf("\rProcessing:\t100.00%%")
fmt.Println("\nDone.")
return k_med
}
// main is used to interpret the parameters,
// start the algorithm and output the results
func main() {
k_ptr := flag.Int("k", 5, "Number of colors to find")
t_ptr := flag.Int("t", 1, "Number of threads to use for computation")
n_ptr := flag.Int("n", 10, "Number of rounds for computation")
// fast_ptr := flag.Bool("fast", false, "Activate fast mode.")
var image_file string
flag.StringVar(&image_file, "image", "", "Image to be processed")
var output_ptr string
flag.StringVar(&output_ptr, "mode", "palette", "Output option")
var output_file_ptr string
flag.StringVar(&output_file_ptr, "o", "image.png", "Output file name")
flag.Parse()
reader, err := os.Open(image_file)
if err != nil {
log.Fatal(err)
}
m, _, err := image.Decode(reader)
if err != nil {
log.Fatal(err)
}
k_med := kmeans(m, *k_ptr, *t_ptr, *n_ptr)
for i := 0; i < len(k_med); i++ {
fmt.Printf("#%02x%02x%02x\n", k_med[i][0], k_med[i][1], k_med[i][2])
}
fmt.Println(output_ptr)
if strings.Compare(output_ptr, "silhouette") == 0 {
img := image.NewRGBA(image.Rectangle{image.Point{0, 0}, image.Point{m.Bounds().Max.X, m.Bounds().Max.Y}})
for x := 0; x < m.Bounds().Max.X; x++ {
for y := 0; y < m.Bounds().Max.Y; y++ {
minimum := *k_ptr
difference := 766
for i := 0; i < *k_ptr; i++ {
R, G, B, _ := m.At(x, y).RGBA()
new_diff := color_diff_euklid([3]int{int(R), int(G), int(B)}, k_med[i])
if new_diff < difference {
difference = new_diff
minimum = i
}
}
img.Set(x, y, color.RGBA{uint8(k_med[minimum][0]), uint8(k_med[minimum][1]), uint8(k_med[minimum][2]), 0xff})
}
}
f, _ := os.Create(output_file_ptr)
png.Encode(f, img)
}
if strings.Compare(output_ptr, "palette") == 0 {
img := image.NewRGBA(image.Rectangle{image.Point{0, 0}, image.Point{m.Bounds().Max.X + 100, m.Bounds().Max.Y}})
for x := 0; x < m.Bounds().Max.X; x++ {
for y := 0; y < m.Bounds().Max.Y; y++ {
img.Set(x, y, m.At(x, y))
}
}
k := *k_ptr
for x := m.Bounds().Max.X; x < m.Bounds().Max.X+100; x++ {
for y := 0; y < m.Bounds().Max.Y; y++ {
img.Set(x, y, color.RGBA{uint8(k_med[(y*k)/m.Bounds().Max.Y][0]), uint8(k_med[(y*k)/m.Bounds().Max.Y][1]), uint8(k_med[(y*k)/m.Bounds().Max.Y][2]), 0xff})
}
}
f, _ := os.Create(output_file_ptr)
png.Encode(f, img)
}
defer reader.Close()
} | img2color.go | 0.58261 | 0.48932 | img2color.go | starcoder |
package datablock
import (
"bytes"
"errors"
"fmt"
"io/ioutil"
"sync"
"github.com/sirupsen/logrus"
)
const emptyFileID = ""
// FileCache manages a set of bytes as a cache
type FileCache struct {
size uint64 // Total size of the cache
blob []byte // The cache storage
index map[string]uint64 // Overview of where the data is placed in the cache
hits map[string]uint64 // Keeping track of data popularity
offset uint64 // The current position in the cache storage (end of data)
rw *sync.RWMutex // Used for avoiding data races and other issues
cacheWarningGiven bool // Used to only warn once if the cache is full
compress bool // Enable data compression
maxEntitySize uint64 // Maximum size per entity in cache
compressionSpeed bool // Prioritize faster or better compression?
verbose bool // Verbose mode?
maxGivenDataSize uint64 // Maximum size of uncompressed data to be stored in cache
}
var (
// ErrRemoval is used if a filename that does not exist is attempted to be removed
ErrRemoval = errors.New("can't remove a file ID that does not exist")
// ErrNoData is used if no data is attempted to be stored in the cache
ErrNoData = errors.New("no data")
// ErrAlreadyStored is used if a given filename has already been stored in the cache
ErrAlreadyStored = errors.New("file ID is already stored")
// ErrLargerThanCache is used if the given data is larger than the total cache size
ErrLargerThanCache = errors.New("data is larger than the the total cache size")
// ErrEntityTooLarge is used if a maximum size per entity has been set
ErrEntityTooLarge = errors.New("data is larger than the allowed size")
// ErrGivenDataSizeTooLarge is returned if the uncompressed size of the given data is too large
ErrGivenDataSizeTooLarge = errors.New("size of given data is larger than allowed")
)
// NewFileCache creates a new FileCache struct.
// cacheSize is the total cache size, in bytes.
// compress is for enabling compression of cache data.
// maxEntitySize is for setting a per-file maximum size. (0 to disable)
// compressionSpeed is if speedy compression should be used over compact compression.
// maxGivenDataSize is the maximum amount of bytes that can be given at once. (0 to disable, 1 MiB is recommended)
func NewFileCache(cacheSize uint64, compress bool, maxEntitySize uint64, compressionSpeed bool, maxGivenDataSize uint64) *FileCache {
var cache FileCache
cache.size = cacheSize
cache.blob = make([]byte, cacheSize) // The cache storage
cache.index = make(map[string]uint64)
cache.hits = make(map[string]uint64)
cache.rw = &sync.RWMutex{}
cache.compress = compress
cache.maxEntitySize = maxEntitySize // Maximum size of data when stored in the cache (possibly compressed). (0 to disable)
cache.compressionSpeed = compressionSpeed // Prioritize compression speed over better compression? set in datablock.go
cache.maxGivenDataSize = maxGivenDataSize // Maximum size of given data to be stored in cache (0 to disable)
return &cache
}
// Normalize the filename
func (cache *FileCache) normalize(filename string) string {
return normalize(filename)
}
// Remove bytes from the cache blob
// i is the position, n is the number of bytes to remove
func (cache *FileCache) removeBytes(i, n uint64) {
cache.blob = append(cache.blob[:i], cache.blob[i+n:]...)
// Extend to the original capacity after removing bytes
cache.blob = cache.blob[:cap(cache.blob)]
}
// IsEmpty checks if the cache is empty
func (cache *FileCache) IsEmpty() bool {
return 0 == len(cache.index)
}
// Shuffle all indices that refers to position after removedpos, offset to the left
// Also moves the end of the data offset to the left
func (cache *FileCache) shuffleIndicesLeft(removedpos, offset uint64) {
for id, pos := range cache.index {
if pos > removedpos {
cache.index[id] -= offset
}
}
}
// Remove a data index
func (cache *FileCache) removeIndex(id string) {
delete(cache.index, id)
}
// Remove data from the cache and shuffle the rest of the data to the left
// Also adjusts all index pointers to indexes larger than the current position
// Also adjusts the cache.offset
func (cache *FileCache) remove(id string) error {
if !cache.hasFile(id) {
return ErrRemoval
}
// Find the position and size of the given id
pos := cache.index[id]
size := cache.dataSize(id)
cache.removeIndex(id)
cache.shuffleIndicesLeft(pos, size)
cache.removeBytes(pos, size)
cache.offset -= uint64(size)
return nil
}
// Find the data with the least hits, that is currently in the cache
func (cache *FileCache) leastPopular() (string, error) {
// If there is no data, return an error
if len(cache.index) == 0 {
return emptyFileID, ErrNoData
}
// Loop through all the data and return the first with no cache hits
for id := range cache.index {
// If there are no cache hits, return this id
foundHit := false
for hitID := range cache.hits {
if hitID == id {
foundHit = true
break
}
}
if !foundHit {
return id, nil
}
}
var (
leastHits uint64
leastHitsID string
firstRound = true
)
// Loop through all the data and find the one with the least cache hits
for id := range cache.index {
// If there is a cache hit, check if it is the first round
if firstRound {
// First candidate
leastHits = cache.hits[id]
leastHitsID = id
firstRound = false
continue
}
// Not the first round, compare with the least popular ID so far
if cache.hits[id] < leastHits {
// Found a less popular ID
leastHits = cache.hits[id]
leastHitsID = id
}
}
// Return the one with the fewest cache hits.
return leastHitsID, nil
}
// Store a file in the cache
// Returns the data (it may be compressed) and an error
func (cache *FileCache) storeData(filename string, data []byte) (storedDataBlock *DataBlock, err error) {
// Check if the given data is too large before attempting to compress it
if cache.maxGivenDataSize != 0 && uint64(len(data)) > cache.maxGivenDataSize {
return nil, ErrGivenDataSizeTooLarge
}
// Compress the data, if compression is enabled
var fileSize uint64
if cache.compress {
compressedData, dataLength, err := compress(data, cache.compressionSpeed)
if err != nil {
return nil, fmt.Errorf("Compression error: %s", err)
}
data = compressedData
fileSize = uint64(dataLength)
} else {
fileSize = uint64(len(data))
}
id := cache.normalize(filename)
if cache.hasFile(id) {
return nil, ErrAlreadyStored
}
if fileSize > cache.size {
return nil, ErrLargerThanCache
}
if cache.maxEntitySize != 0 && fileSize > cache.maxEntitySize {
return nil, ErrEntityTooLarge
}
// Warn once that the cache is now full
if !cache.cacheWarningGiven && fileSize > cache.freeSpace() {
logrus.Warn("Cache is full. You may want to increase the cache size.")
cache.cacheWarningGiven = true
}
// While there is not enough space, remove the least popular data
for fileSize > cache.freeSpace() {
// Find the least popular data
removeID, err := cache.leastPopular()
if err != nil {
return nil, err
}
// Remove it
if cache.verbose {
logrus.Info(fmt.Sprintf("Removing the unpopular %v from the cache (%d bytes)", removeID, cache.dataSize(removeID)))
}
spaceBefore := cache.freeSpace()
err = cache.remove(removeID)
if err != nil {
return nil, err
}
spaceAfter := cache.freeSpace()
// Panic if there is no more free cache space after removing data
if spaceBefore == spaceAfter {
panic(fmt.Sprintf("Removed %v, but the free space is the same! Still %d bytes.", removeID, spaceAfter))
}
}
if cache.verbose {
logrus.Info(fmt.Sprintf("Storing in cache: %v", id))
}
// Register the position in the data index
cache.index[id] = cache.offset
// Copy the contents to the cache
var i uint64
for i = 0; i < fileSize; i++ {
cache.blob[cache.offset+i] = data[i]
}
// Move the offset to the end of the data (the next free location)
cache.offset += uint64(fileSize)
return newDataBlockSpecified(data, cache.compress, cache.compressionSpeed), nil
}
// Check if the given filename exists in the cache
func (cache *FileCache) hasFile(id string) bool {
for key := range cache.index {
if key == id {
return true
}
}
return false
}
// Find the next start of a data block, given a position
// Returns a position and true if a next position was found
func (cache *FileCache) nextData(startpos uint64) (uint64, bool) {
// Find the end of the data (larger than startpos, but smallest diff)
datasize := cache.size - startpos // Largest possible data size
endpos := startpos // Initial end of data
found := false
for _, pos := range cache.index {
if pos > startpos && (pos-startpos) < datasize {
datasize = (pos - startpos)
endpos = pos
found = true
}
}
// endpos is the next start of a data block
return endpos, found
}
// Find the size of a cached data block. id must exist.
func (cache *FileCache) dataSize(id string) uint64 {
startpos := cache.index[id]
// Find the next data block
endpos, foundNext := cache.nextData(startpos)
// Use the end of data as the end position, if no next position is found
if !foundNext {
endpos = cache.offset
}
return endpos - startpos
}
// Store a file in the cache
// Return true if we got the data from the file, regardless of cache errors.
func (cache *FileCache) storeFile(filename string) (*DataBlock, bool, error) {
// Read the file
data, err := ioutil.ReadFile(filename)
if err != nil {
return nil, false, err
}
// Store in cache, log a warning if the cache has filled up and needs to make space every time
_, err = cache.storeData(filename, data)
// Return the uncompressed data
return NewDataBlock(data, cache.compressionSpeed), true, err
}
// Retrieve a file from the cache, or from disk
func (cache *FileCache) fetchAndCache(filename string) (*DataBlock, error) {
// RWMutex locks
cache.rw.Lock()
defer cache.rw.Unlock()
id := cache.normalize(filename)
// Check if the file needs to be read from disk
fileCached := cache.hasFile(id)
if !fileCached {
if cache.verbose {
logrus.Info("Reading from disk: " + string(id))
logrus.Info("Storing in cache: " + string(id))
}
block, gotTheData, err := cache.storeFile(string(id))
// Cache errors are logged as warnings, and not being returned
if err != nil {
// Log cache errors as warnings (could be that the file is too large)
if cache.verbose {
logrus.Warn(err)
}
}
// Only return an error here if we were not able to read the file from disk
if !gotTheData {
return nil, err
}
// Return the data, with no errors to report
return block, nil
}
if cache.verbose {
logrus.Info("Retrieving from cache: " + string(id))
}
// Find the start of the data
startpos := cache.index[id]
// Find the size of the data
size := cache.dataSize(id)
// Copy the data from the cache
data := make([]byte, size)
var i uint64
for i = 0; i < size; i++ {
data[i] = cache.blob[startpos+i]
}
// Mark a cache hit
cache.hits[id]++
// Return the data block
return newDataBlockSpecified(data, cache.compress, cache.compressionSpeed), nil
}
func (cache *FileCache) freeSpace() uint64 {
return cache.size - cache.offset
}
// Stats returns formatted cache statistics
func (cache *FileCache) Stats() string {
cache.rw.Lock()
defer cache.rw.Unlock()
var buf bytes.Buffer
buf.WriteString("Cache information:\n")
buf.WriteString(fmt.Sprintf("\tCompression:\t%s\n", map[bool]string{true: "enabled", false: "disabled"}[cache.compress]))
buf.WriteString(fmt.Sprintf("\tTotal cache:\t%d bytes\n", cache.size))
buf.WriteString(fmt.Sprintf("\tFree cache:\t%d bytes\n", cache.freeSpace()))
buf.WriteString(fmt.Sprintf("\tEnd of data:\tat %d\n", cache.offset))
if len(cache.index) > 0 {
buf.WriteString("\tData in cache:\n")
for id, pos := range cache.index {
buf.WriteString(fmt.Sprintf("\t\tid=%v\tpos=%d\tsize=%d\n", id, pos, cache.dataSize(id)))
}
}
var totalHits uint64
if len(cache.hits) > 0 {
buf.WriteString("\tCache hits:\n")
for id, hits := range cache.hits {
buf.WriteString(fmt.Sprintf("\t\tid=%v\thits=%d\n", id, hits))
totalHits += hits
}
buf.WriteString(fmt.Sprintf("\tTotal cache hits:\t%d", totalHits))
}
return buf.String()
}
// Clear the entire cache
func (cache *FileCache) Clear() {
cache.rw.Lock()
defer cache.rw.Unlock()
cache.offset = 0
cache.index = make(map[string]uint64)
cache.hits = make(map[string]uint64)
// No need to clear the actual bytes, unless perhaps if there should be
// changes to the caching algorithm in the future.
//cache.blob = make([]byte, cache.size)
// Allow one warning if the cache should fill up
cache.cacheWarningGiven = false
}
// For reading files, with optional caching.
func (cache *FileCache) Read(filename string, cached bool) (*DataBlock, error) {
if cached {
// Read the file from cache (or disk, if not cached)
return cache.fetchAndCache(filename)
}
// Normalize the filename
filename = string(cache.normalize(filename))
if cache.verbose {
logrus.Info("Reading from disk: " + filename)
}
// Read the file
data, err := ioutil.ReadFile(filename)
if err != nil {
return nil, err
}
// Return the uncompressed data
return NewDataBlock(data, cache.compressionSpeed), nil
} | vendor/github.com/xyproto/datablock/filecache.go | 0.621311 | 0.474692 | filecache.go | starcoder |
package solver
import "github.com/truggeri/go-sudoku/cmd/go-sudoku/puzzle"
type solveTechnique struct {
set func(int, int) puzzle.Set
index func(int, int) int
}
type solution struct {
x, y int
square puzzle.Square
}
// Solve Returns the given puzzle with all elements solved
func Solve(puz puzzle.Puzzle) puzzle.Puzzle {
for true {
puz = puz.CalculatePossibilities()
newSolution := false
var answer solution
techniques := [4]func(puzzle.Puzzle) (bool, solution){solveUniques, solveRows, solveColumns, solveCubes}
for _, technique := range techniques {
newSolution, answer = technique(puz)
if newSolution {
puz[answer.x][answer.y] = answer.square
break
}
}
if !newSolution {
break
}
}
return puz
}
func solveUniques(puz puzzle.Puzzle) (bool, solution) {
for x := 0; x < puzzle.LineWidth; x++ {
for y := 0; y < puzzle.LineWidth; y++ {
if puz[x][y].Solved() {
continue
}
onlyOne, value := onlyOnePossibility(puz[x][y].Possibilities)
if onlyOne {
return true, solution{x: x, y: y, square: puzzle.CreatePuzzleSquare(value)}
}
}
}
return false, solution{}
}
func onlyOnePossibility(poss puzzle.Possibilies) (bool, int) {
counter, onlyOption := 0, 0
for i, v := range poss {
if v {
onlyOption = i + 1
counter++
}
if counter > 1 {
return false, 0
}
}
return true, onlyOption
}
func solveRows(puz puzzle.Puzzle) (bool, solution) {
set := func(x, y int) puzzle.Set {
return puz.GetRow(x)
}
index := func(x, y int) int {
return y
}
return solveByElement(puz, solveTechnique{set, index})
}
func solveByElement(puz puzzle.Puzzle, st solveTechnique) (bool, solution) {
for x := 0; x < puzzle.LineWidth; x++ {
for y := 0; y < puzzle.LineWidth; y++ {
if puz[x][y].Solved() {
continue
}
updated, result := solveSet(st.set(x, y), st.index(x, y))
if updated {
return true, solution{x: x, y: y, square: result}
}
}
}
return false, solution{}
}
func solveSet(set puzzle.Set, i int) (bool, puzzle.Square) {
if set[i].Solved() {
return false, set[i]
}
setOptions := set.Possibilities(i)
for j := range setOptions {
if set[i].Possibilities[j] && !setOptions[j] {
return true, puzzle.CreatePuzzleSquare(j + 1)
}
}
return false, set[i]
}
func solveColumns(puz puzzle.Puzzle) (bool, solution) {
set := func(x, y int) puzzle.Set {
return puz.GetColumn(y)
}
index := func(x, y int) int {
return x
}
return solveByElement(puz, solveTechnique{set, index})
}
func solveCubes(puz puzzle.Puzzle) (bool, solution) {
set := func(x, y int) puzzle.Set {
return puz.GetCube(x, y)
}
index := puzzle.PositionInCube
return solveByElement(puz, solveTechnique{set, index})
} | cmd/go-sudoku/solver/solver.go | 0.656328 | 0.494263 | solver.go | starcoder |
package bench
import (
"fmt"
"time"
histwriter "github.com/kishansairam9/bench/v2/hdrhistogram-writer"
"github.com/HdrHistogram/hdrhistogram-go"
)
// Summary contains the results of a Benchmark run.
type Summary struct {
Connections uint64
RequestRate uint64
SuccessTotal uint64
ErrorTotal uint64
TimeElapsed time.Duration
SuccessHistogram *hdrhistogram.Histogram
UncorrectedSuccessHistogram *hdrhistogram.Histogram
ErrorHistogram *hdrhistogram.Histogram
UncorrectedErrorHistogram *hdrhistogram.Histogram
Throughput float64
}
// String returns a stringified version of the Summary.
func (s *Summary) String() string {
return fmt.Sprintf(
"\n{Connections: %d, RequestRate: %d, RequestTotal: %d, SuccessTotal: %d, ErrorTotal: %d, TimeElapsed: %s, Throughput: %.2f/s}",
s.Connections, s.RequestRate, (s.SuccessTotal + s.ErrorTotal), s.SuccessTotal, s.ErrorTotal, s.TimeElapsed, s.Throughput)
}
// GenerateLatencyDistribution generates a text file containing the specified
// latency distribution in a format plottable by
// http://hdrhistogram.github.io/HdrHistogram/plotFiles.html. Percentiles is a
// list of percentiles to include, e.g. 10.0, 50.0, 99.0, 99.99, etc. If
// percentiles is nil, it defaults to a logarithmic percentile scale. If a
// request rate was specified for the benchmark, this will also generate an
// uncorrected distribution file which does not account for coordinated
// omission.
func (s *Summary) GenerateLatencyDistribution(percentiles histwriter.Percentiles, file string) error {
return generateLatencyDistribution(s.SuccessHistogram, s.UncorrectedSuccessHistogram, s.RequestRate, percentiles, file)
}
// GenerateErrorLatencyDistribution generates a text file containing the specified
// latency distribution (of requests that resulted in errors) in a format plottable by
// http://hdrhistogram.github.io/HdrHistogram/plotFiles.html. Percentiles is a
// list of percentiles to include, e.g. 10.0, 50.0, 99.0, 99.99, etc. If
// percentiles is nil, it defaults to a logarithmic percentile scale. If a
// request rate was specified for the benchmark, this will also generate an
// uncorrected distribution file which does not account for coordinated
// omission.
func (s *Summary) GenerateErrorLatencyDistribution(percentiles histwriter.Percentiles, file string) error {
return generateLatencyDistribution(s.ErrorHistogram, s.UncorrectedErrorHistogram, s.RequestRate, percentiles, file)
}
func getOneByPercentile(percentile float64) float64 {
if percentile < 100 {
return 1 / (1 - (percentile / 100))
}
return float64(10000000)
}
func generateLatencyDistribution(histogram, unHistogram *hdrhistogram.Histogram, requestRate uint64, percentiles histwriter.Percentiles, file string) error {
scaleFactor := 0.000001 // Scale ns to ms.
if err := histwriter.WriteDistributionFile(histogram, percentiles, scaleFactor, file); err != nil {
return err
}
// Generate uncorrected distribution.
if requestRate > 0 {
if err := histwriter.WriteDistributionFile(unHistogram, percentiles, scaleFactor, fmt.Sprintf("uncorrected_%s", file)); err != nil {
return err
}
}
return nil
}
// merge the other Summary into this one.
func (s *Summary) merge(o *Summary) {
if o.TimeElapsed > s.TimeElapsed {
s.TimeElapsed = o.TimeElapsed
}
s.SuccessHistogram.Merge(o.SuccessHistogram)
s.UncorrectedSuccessHistogram.Merge(o.UncorrectedSuccessHistogram)
s.ErrorHistogram.Merge(o.ErrorHistogram)
s.UncorrectedErrorHistogram.Merge(o.UncorrectedErrorHistogram)
s.SuccessTotal += o.SuccessTotal
s.ErrorTotal += o.ErrorTotal
s.Throughput += o.Throughput
s.RequestRate += o.RequestRate
} | summary.go | 0.788543 | 0.474631 | summary.go | starcoder |
package ws
import (
"errors"
"fmt"
)
// ServiceErrorCategory indicates the broad 'type' of a service error, used to determine the correct HTTP status code to use.
type ServiceErrorCategory int
const (
// Unexpected is an unhandled error that will generally result in an HTTP 500 status code being set.
Unexpected = iota
// Client is a problem that the calling client has caused or could have foreseen, generally resulting in an HTTP 400 status code.
Client
// Logic is a problem that the calling client could not be expected to have foreseen (email address in use, for example) resulting in an HTTP 409.
Logic
// Security is an access or authentication error that might result in an HTTP 401 or 403.
Security
// HTTP is an error that forces a specific HTTP status code.
HTTP
)
// CategorisedError is a service error with a concept of the general 'type' of error it is.
type CategorisedError struct {
// The broad type of error, which influences the eventual HTTP status code set on the response.
Category ServiceErrorCategory
// A unique code that a caller can rely on to identify a specific error or that can be used to lookup an error message.
Code string
// A message suitable for displaying to the caller.
Message string
//If this error relates to a specific field or parameter in a web service request, this field is set to the name of that field.
Field string
}
// NewCategorisedError creates a new CategorisedError with every field expect 'Field' set.
func NewCategorisedError(category ServiceErrorCategory, code string, message string) *CategorisedError {
ce := new(CategorisedError)
ce.Category = category
ce.Code = code
ce.Message = message
return ce
}
// ServiceErrorFinder is implemented by a component that is able to find a message and error category given the code for an error
type ServiceErrorFinder interface {
//Find takes a code and returns the message and category for that error. Behaviour undefined if code is not
// recognised.
Find(code string) *CategorisedError
}
// ServiceErrorConsumer is implemented by components that require a ServiceErrorFinder to be injected into them
type ServiceErrorConsumer interface {
// ProvideErrorFinder receives a ServiceErrorFinder
ProvideErrorFinder(finder ServiceErrorFinder)
}
// ServiceErrors is a structure that records each of the errors found during the processing of a request.
type ServiceErrors struct {
// All services found, in the order in which they occured.
Errors []CategorisedError
// An externally computed HTTP status code that reflects the mix of errors in this structure.
HTTPStatus int
// A component able to find additional information about error from that error's unique code.
ErrorFinder ServiceErrorFinder
}
// AddNewError creates a new CategorisedError from the supplied information and captures it.
func (se *ServiceErrors) AddNewError(category ServiceErrorCategory, label string, message string) {
error := CategorisedError{category, label, message, ""}
se.Errors = append(se.Errors, error)
}
// AddError records the supplied error.
func (se *ServiceErrors) AddError(e *CategorisedError) {
se.Errors = append(se.Errors, *e)
}
// AddPredefinedError creates a CategorisedError by looking up the supplied code and records that error. If the variadic field
// parameter is supplied, the created error will be associated with that field name.
func (se *ServiceErrors) AddPredefinedError(code string, field ...string) error {
if se.ErrorFinder == nil {
panic("No source of errors defined")
}
e := se.ErrorFinder.Find(code)
if len(field) > 0 {
e.Field = field[0]
}
if e == nil {
message := fmt.Sprintf("An error occured with code %s, but no error message is available", code)
e = NewCategorisedError(Unexpected, code, message)
}
se.Errors = append(se.Errors, *e)
return nil
}
// HasErrors returns true if one or more errors have been encountered and recorded.
func (se *ServiceErrors) HasErrors() bool {
return len(se.Errors) != 0
}
// CodeToCategory takes the short form of a category's name (its first letter, capitialised) an maps
// that to a ServiceErrorCategory
func CodeToCategory(c string) (ServiceErrorCategory, error) {
switch c {
case "U":
return Unexpected, nil
case "C":
return Client, nil
case "L":
return Logic, nil
case "S":
return Security, nil
default:
message := fmt.Sprintf("Unknown error category %s", c)
return -1, errors.New(message)
}
}
// CategoryToCode maps a ServiceErrorCategory to the category's name's first letter. For example, Security maps to
// 'S'
func CategoryToCode(c ServiceErrorCategory) string {
switch c {
default:
return "?"
case Unexpected:
return "U"
case Security:
return "S"
case Logic:
return "L"
case Client:
return "C"
case HTTP:
return "H"
}
}
// CategoryToName maps a ServiceErrorCategory to the category's name's first letter. For example, Security maps to
// 'Security'
func CategoryToName(c ServiceErrorCategory) string {
switch c {
default:
return "Unknown"
case Unexpected:
return "Unexpected"
case Security:
return "Security"
case Logic:
return "Logic"
case Client:
return "Client"
case HTTP:
return "HTTP"
}
} | ws/error.go | 0.740644 | 0.495117 | error.go | starcoder |
package subspace
import (
"bytes"
"errors"
"github.com/abdullin/lex-go/tuple"
"github.com/abdullin/lex-go"
)
// Subspace represents a well-defined region of keyspace in a FoundationDB
// database.
type Subspace interface {
// Sub returns a new Subspace whose prefix extends this Subspace with the
// encoding of the provided element(s). If any of the elements are not a
// valid tuple.Element, Sub will panic.
Sub(el ...tuple.Element) Subspace
// Bytes returns the literal bytes of the prefix of this Subspace.
Bytes() []byte
// Pack returns the key encoding the specified Tuple with the prefix of this
// Subspace prepended.
Pack(t tuple.Tuple) lex.Key
// Unpack returns the Tuple encoded by the given key with the prefix of this
// Subspace removed. Unpack will return an error if the key is not in this
// Subspace or does not encode a well-formed Tuple.
Unpack(k lex.KeyConvertible) (tuple.Tuple, error)
// Contains returns true if the provided key starts with the prefix of this
// Subspace, indicating that the Subspace logically contains the key.
Contains(k lex.KeyConvertible) bool
// All Subspaces implement lex.KeyConvertible and may be used as
// FoundationDB keys (corresponding to the prefix of this Subspace).
lex.KeyConvertible
// All Subspaces implement lex.ExactRange and lex.Range, and describe all
// keys logically in this Subspace.
lex.ExactRange
}
type subspace struct {
b []byte
}
// AllKeys returns the Subspace corresponding to all keys in a FoundationDB
// database.
func AllKeys() Subspace {
return subspace{}
}
// Sub returns a new Subspace whose prefix is the encoding of the provided
// element(s). If any of the elements are not a valid tuple.Element, a
// runtime panic will occur.
func Sub(el ...tuple.Element) Subspace {
return subspace{tuple.Tuple(el).Pack()}
}
// FromBytes returns a new Subspace from the provided bytes.
func FromBytes(b []byte) Subspace {
s := make([]byte, len(b))
copy(s, b)
return subspace{s}
}
func (s subspace) Sub(el ...tuple.Element) Subspace {
return subspace{concat(s.Bytes(), tuple.Tuple(el).Pack()...)}
}
func (s subspace) Bytes() []byte {
return s.b
}
func (s subspace) Pack(t tuple.Tuple) lex.Key {
return lex.Key(concat(s.b, t.Pack()...))
}
func (s subspace) Unpack(k lex.KeyConvertible) (tuple.Tuple, error) {
key := k.LexKey()
if !bytes.HasPrefix(key, s.b) {
return nil, errors.New("key is not in subspace")
}
return tuple.Unpack(key[len(s.b):])
}
func (s subspace) Contains(k lex.KeyConvertible) bool {
return bytes.HasPrefix(k.LexKey(), s.b)
}
func (s subspace) LexKey() lex.Key {
return lex.Key(s.b)
}
func (s subspace) LexRangeKeys() (lex.KeyConvertible, lex.KeyConvertible) {
return lex.Key(concat(s.b, 0x00)), lex.Key(concat(s.b, 0xFF))
}
func (s subspace) LexRangeKeySelectors() (lex.Selectable, lex.Selectable) {
begin, end := s.LexRangeKeys()
return lex.FirstGreaterOrEqual(begin), lex.FirstGreaterOrEqual(end)
}
func concat(a []byte, b ...byte) []byte {
r := make([]byte, len(a)+len(b))
copy(r, a)
copy(r[len(a):], b)
return r
} | subspace/subspace.go | 0.8789 | 0.435181 | subspace.go | starcoder |
package tuples
import (
"math"
)
// Tuple data type
type Tuple struct {
X float64
Y float64
Z float64
W float64
}
// NewTuple returns tuple
func NewTuple(x float64, y float64, z float64, w float64) Tuple {
return Tuple{x, y, z, w}
}
// NewPoint returns tuple with w = 1
func NewPoint(x float64, y float64, z float64) Tuple {
return Tuple{x, y, z, 1}
}
// NewVector returns tuple with w = 0
func NewVector(x float64, y float64, z float64) Tuple {
return Tuple{x, y, z, 0}
}
// FloatEqual checks if 2 floats are equal
func FloatEqual(val1 float64, val2 float64) bool {
const EPSILLON = .00001
return math.Abs(val1-val2) < EPSILLON
}
// Equal checks if 2 tuples are equal
func Equal(tup1 Tuple, tup2 Tuple) bool {
if FloatEqual(tup1.X, tup2.X) && FloatEqual(tup1.Y, tup2.Y) && FloatEqual(tup1.Z, tup2.Z) && FloatEqual(tup1.W, tup2.W) {
return true
}
return false
}
// Add adds 2 tuples together
func Add(tup1 Tuple, tup2 Tuple) Tuple {
return NewTuple(
tup1.X+tup2.X,
tup1.Y+tup2.Y,
tup1.Z+tup2.Z,
tup1.W+tup2.W,
)
}
// Subtract subracts 2 tuples
func Subtract(tup1 Tuple, tup2 Tuple) Tuple {
return NewTuple(
tup1.X-tup2.X,
tup1.Y-tup2.Y,
tup1.Z-tup2.Z,
tup1.W-tup2.W,
)
}
// Negate negates a tuple
func (tup Tuple) Negate() Tuple {
return NewTuple(
-tup.X,
-tup.Y,
-tup.Z,
-tup.W,
)
}
// Multiply multiplies a tuple by a scalar
func Multiply(tup Tuple, val float64) Tuple {
return NewTuple(
tup.X*val,
tup.Y*val,
tup.Z*val,
tup.W*val,
)
}
// Divide divides a tuple by a scalar
func Divide(tup Tuple, val float64) Tuple {
return NewTuple(
tup.X/val,
tup.Y/val,
tup.Z/val,
tup.W/val,
)
}
// Magnitude calculates the magnitude of a tuple
func (tup Tuple) Magnitude() float64 {
squareSum := math.Pow(tup.X, 2) + math.Pow(tup.Y, 2) + math.Pow(tup.Z, 2) + math.Pow(tup.W, 2)
return math.Sqrt(squareSum)
}
// Normalize normalizes a tuple
func (tup Tuple) Normalize() Tuple {
magnitude := tup.Magnitude()
return NewTuple(
tup.X/magnitude,
tup.Y/magnitude,
tup.Z/magnitude,
tup.W/magnitude,
)
}
// DotProduct computes the dot product of 2 tuples
func DotProduct(tup1 Tuple, tup2 Tuple) float64 {
return (tup1.X*tup2.X +
tup1.Y*tup2.Y +
tup1.Z*tup2.Z +
tup1.W*tup2.W)
}
// CrossProduct returns a cross product vector of 2 vectors
func CrossProduct(vector1 Tuple, vector2 Tuple) Tuple {
return NewVector(
vector1.Y*vector2.Z-vector1.Z*vector2.Y,
vector1.Z*vector2.X-vector1.X*vector2.Z,
vector1.X*vector2.Y-vector1.Y*vector2.X)
} | pkg/tuples/tuples.go | 0.876555 | 0.739611 | tuples.go | starcoder |
package core
import (
"math/big"
"github.com/offchainlabs/arbitrum/packages/arb-util/common"
"github.com/offchainlabs/arbitrum/packages/arb-util/hashing"
)
type NodeState struct {
ProposedBlock *big.Int
InboxMaxCount *big.Int
*ExecutionState
}
type Assertion struct {
Before *ExecutionState
After *ExecutionState
}
func newExecutionStateFromFields(a [3][32]byte, b [4]*big.Int) *ExecutionState {
return &ExecutionState{
TotalGasConsumed: b[0],
MachineHash: a[0],
TotalMessagesRead: b[1],
TotalSendCount: b[2],
TotalLogCount: b[3],
SendAcc: a[1],
LogAcc: a[2],
}
}
func NewAssertionFromFields(a [2][3][32]byte, b [2][4]*big.Int) *Assertion {
return &Assertion{
Before: newExecutionStateFromFields(a[0], b[0]),
After: newExecutionStateFromFields(a[1], b[1]),
}
}
func stateByteFields(s *ExecutionState) [3][32]byte {
return [3][32]byte{
s.MachineHash,
s.SendAcc,
s.LogAcc,
}
}
func (a *Assertion) BytesFields() [2][3][32]byte {
return [2][3][32]byte{
stateByteFields(a.Before),
stateByteFields(a.After),
}
}
func stateIntFields(s *ExecutionState) [4]*big.Int {
return [4]*big.Int{
s.TotalGasConsumed,
s.TotalMessagesRead,
s.TotalSendCount,
s.TotalLogCount,
}
}
func (a *Assertion) IntFields() [2][4]*big.Int {
return [2][4]*big.Int{
stateIntFields(a.Before),
stateIntFields(a.After),
}
}
func BisectionChunkHash(
segmentStart *big.Int,
segmentLength *big.Int,
startHash common.Hash,
endHash common.Hash,
) common.Hash {
return hashing.SoliditySHA3(
hashing.Uint256(segmentStart),
hashing.Uint256(segmentLength),
hashing.Bytes32(startHash),
hashing.Bytes32(endHash),
)
}
func (a *Assertion) BeforeExecutionHash() common.Hash {
return a.Before.CutHash()
}
func (a *Assertion) AfterExecutionHash() common.Hash {
return a.After.CutHash()
}
func (a *Assertion) ExecutionHash() common.Hash {
return BisectionChunkHash(
a.Before.TotalGasConsumed,
new(big.Int).Sub(a.After.TotalGasConsumed, a.Before.TotalGasConsumed),
a.BeforeExecutionHash(),
a.AfterExecutionHash(),
)
}
func (a *Assertion) CheckTime(arbGasSpeedLimitPerBlock *big.Int) *big.Int {
gasUsed := new(big.Int).Sub(a.After.TotalGasConsumed, a.Before.TotalGasConsumed)
return new(big.Int).Div(gasUsed, arbGasSpeedLimitPerBlock)
} | packages/arb-util/core/assertion.go | 0.635222 | 0.421016 | assertion.go | starcoder |
package utils
import (
"encoding/binary"
"errors"
"fmt"
"log"
"math"
"strings"
)
func CheckError(err error) {
if err != nil {
log.Panic(err)
}
}
// Int32ToByteArray transforms int32 value to byte array using fixed length encoding
// Returns byte array of size 4
// Reversed conversion is possible only with ByteArrayToInt32 function
func Int32ToByteArray(number int32) []byte {
bs := make([]byte, 4)
unsigned := uint32(number)
binary.LittleEndian.PutUint32(bs, unsigned)
return bs
}
// ByteArrayToInt32 transforms byte array of size 4 to int32
// Returns int32 value and error if length of byte array != 4
// Reversed conversion is possible only with Int32ToByteArray function
func ByteArrayToInt32(bs []byte) (int32, error) {
if len(bs) != 4 {
errorMessage := fmt.Sprintf("converter: wrong bs array length. Expected array length of 4, " +
"actual length is %d", len(bs))
return -1, errors.New(errorMessage)
}
unsigned := binary.LittleEndian.Uint32(bs)
number := int32(unsigned)
return number, nil
}
func Int8ToByteArray(number int8) []byte {
bs := make([]byte, 1)
bs[0] = byte(number)
return bs
}
func ByteArrayToInt8(bs []byte) int8 {
var number int8
number = int8(bs[0])
return number
}
// BoolToByteArray transforms bool value to byte array
// Returns byte array of size 1
// Reversed conversion is possible only with ByteArrayToBool function
func BoolToByteArray(flag bool) []byte {
bs := make([]byte, 1)
if flag {
bs[0] = 0x01
} else {
bs[0] = 0x00
}
return bs
}
// ByteArrayToBool tansforms byte array of size 1 to bool
// Returns bool value and error if byte array size is not 1 or it contains bad data
// Reversed conversion is possible only with BoolToByteArray function
func ByteArrayToBool(bs []byte) (bool, error) {
if len(bs) != 1 {
errorMessage := fmt.Sprintf("converter: wrong byte array length. expected array length is 1, actual length is %d", len(bs))
return false, errors.New(errorMessage)
}
if bs[0] == 0x00 {
return false, nil
} else if bs[0] == 0x01 {
return true, nil
} else {
errorMessage := fmt.Sprintf("converter: byte array contains bad data")
return false, errors.New(errorMessage)
}
}
// StringToByteArray transforms string to byte array
// Returns byte array of size len(string)
func StringToByteArray(s string) []byte {
return []byte(s)
}
// ByteArrayToString transforms byte array to string
// Returns string of length equal to array size
func ByteArrayToString(bs []byte) string {
return string(bs)
}
// Float64ToByteArray transforms float64 to byte array
// Returns byte array of size 8
func Float64ToByteArray(number float64) []byte {
bits := math.Float64bits(number)
bytes := make([]byte, 8)
binary.LittleEndian.PutUint64(bytes, bits)
return bytes
}
// ByteArrayToFloat64 transforms byte array of size 8 to float64
// Returns float64 value and error if byte array size is not 8
func ByteArrayToFloat64(bs []byte) (float64, error) {
if len(bs) != 8 {
errorMessage := fmt.Sprintf("converter: wrong bs array length. Expected array length of 8, " +
"actual length is %d", len(bs))
return -1, errors.New(errorMessage)
}
bits := binary.LittleEndian.Uint64(bs)
float := math.Float64frombits(bits)
return float, nil
}
// If string parameter length is less than requiredLength then '#' character is added to the end of string
func AddStopCharacter(str string, requiredLength int) string {
for len(str) < requiredLength {
str += "#"
}
return str
}
// Returns string slice until the '#' character
func RemoveStopCharacter(str string) string {
i := strings.Index(str, "#")
if i > -1 {
return str[:i]
} else {
return str
}
} | internal/pkg/utils/utils.go | 0.78695 | 0.465448 | utils.go | starcoder |
package faker
import (
"fmt"
"math/rand"
"strings"
"time"
)
// Faker is struct for Faker
type Faker struct {
Generator *rand.Rand
firstNameMale []string
firstNameFemale []string
lastName []string
maleNameFormat []string
femaleNameFormat []string
usernameFormat []string
// Generic top-level domain
gTLD []string
}
// NewFaker returns a new instance of Faker instance with a random seed
func NewFaker() Faker {
source := rand.NewSource(time.Now().Unix())
return Faker{
Generator: rand.New(source),
firstNameMale: []string{
"Alexander", "Anthony",
"Daniel",
"Elon",
"Freddie",
"James", "John",
"Leo",
"Matthew",
"Oliver",
"Robert",
"Sergey",
},
firstNameFemale: []string{
"Alice",
"Grace",
"Jennifer",
"Luna",
"Mary", "Maya", "Mia",
"Patricia",
"Ruby",
"Willow",
},
lastName: []string{
"Adams", "Anderson",
"Brin", "Brown",
"Carter", "Clarke",
"Evans",
"Fisher", "Fletcher", "Ford", "Fox",
"Green",
"Jackson", "Johnson", "Jones",
"Lewis",
"Miller", "Musk",
"Owen",
"Pike",
"Smith",
"Walker", "Williams",
},
maleNameFormat: []string{
"{{firstNameMale}} {{lastName}}",
"{{firstNameMale}} {{lastName}}",
"{{firstNameMale}} {{lastName}}",
"{{firstNameMale}} {{lastName}}",
"{{lastName}} {{firstNameMale}}",
},
femaleNameFormat: []string{
"{{firstNameFemale}} {{lastName}}",
"{{firstNameFemale}} {{lastName}}",
"{{firstNameFemale}} {{lastName}}",
"{{firstNameFemale}} {{lastName}}",
"{{lastName}} {{firstNameFemale}}",
},
usernameFormat: []string{
"{{lastName}}.{{firstName}}",
"{{firstName}}.{{lastName}}",
"{{firstName}}",
"{{lastName}}",
},
gTLD: []string{
"com",
"info",
"net",
"org",
},
}
}
// Boolean returns Boolean instance
func (f Faker) Boolean() Boolean {
return Boolean{&f}
}
// Internet returns Internet instance
func (f Faker) Internet() Internet {
return Internet{&f}
}
// Person returns Person instance
func (f Faker) Person() Person {
return Person{&f}
}
// UUID returns UUID instance
func (f Faker) UUID() UUID {
return UUID{&f}
}
// IntBetween returns a Int between a given minimum and maximum values
func (f Faker) IntBetween(min, max int) int {
diff := max - min
if diff == 0 {
return min
}
return f.Generator.Intn(diff+1) + min
}
// RandomStringElement returns a random string element from a given list of strings
func (f Faker) RandomStringElement(s []string) string {
i := f.IntBetween(0, len(s)-1)
return s[i]
}
// Asciify returns string that replace all "*" characters with random ASCII values from a given string
func (f Faker) Asciify(in string) string {
var out strings.Builder
for i := 0; i < len(in); i++ {
if in[i] == '*' {
out.WriteString(fmt.Sprintf("%c", f.IntBetween(97, 122)))
} else {
out.WriteByte(in[i])
}
}
return out.String()
}
// ByName returns random data by faker
func (f Faker) ByName(faker string) any {
switch strings.ToLower(faker) {
// Boolean
case "boolean":
return f.Boolean().Boolean()
// Internet
case "username":
return f.Internet().Username()
case "gtld":
return f.Internet().GTLD()
case "domain":
return f.Internet().Domain()
case "email":
return f.Internet().Email()
// Person
case "firstname", "person.firstname":
return f.Person().FirstName()
case "lastname", "person.lastname":
return f.Person().LastName()
case "firstname male", "person.firstnamemale":
return f.Person().FirstNameMale()
case "firstname female", "person.firstnamefemale":
return f.Person().FirstNameFemale()
case "name", "person.name":
return f.Person().Name()
case "name male", "person.namemale":
return f.Person().NameMale()
case "name female", "person.namefemale":
return f.Person().NameFemale()
case "gender", "person.gender":
return f.Person().Gender()
case "gender male", "person.gendermale":
return f.Person().GenderMale()
case "gender female", "person.genderfemale":
return f.Person().GenderFemale()
// UUID
case "uuid":
return f.UUID().V4()
default:
return nil
}
} | internal/faker/faker.go | 0.53048 | 0.430327 | faker.go | starcoder |
package types
type Data map[string]interface{}
func (d *Data) Set(key string, value interface{}) {
if *d == nil {
*d = make(Data)
}
(*d)[key] = value
}
func (d Data) Get(key string) interface{} {
return d[key]
}
func (d Data) Has(key string) bool {
_, ok := d[key]
return ok
}
func (d Data) Lookup(key string) (value interface{}, ok bool) {
value, ok = d[key]
return
}
func (d Data) Delete(key string) {
delete(d, key)
}
func (d Data) GetBool(key string) bool {
v, _ := d.Get(key).(bool)
return v
}
func (d Data) GetInt(key string) int {
v, _ := d.Get(key).(int)
return v
}
func (d Data) GetInt8(key string) int8 {
v, _ := d.Get(key).(int8)
return v
}
func (d Data) GetInt16(key string) int16 {
v, _ := d.Get(key).(int16)
return v
}
func (d Data) GetInt32(key string) int32 {
v, _ := d.Get(key).(int32)
return v
}
func (d Data) GetInt64(key string) int64 {
v, _ := d.Get(key).(int64)
return v
}
func (d Data) GetUint(key string) uint {
v, _ := d.Get(key).(uint)
return v
}
func (d Data) GetUint8(key string) uint8 {
v, _ := d.Get(key).(uint8)
return v
}
func (d Data) GetUint16(key string) uint16 {
v, _ := d.Get(key).(uint16)
return v
}
func (d Data) GetUint32(key string) uint32 {
v, _ := d.Get(key).(uint32)
return v
}
func (d Data) GetUint64(key string) uint64 {
v, _ := d.Get(key).(uint64)
return v
}
func (d Data) GetFloat32(key string) float32 {
v, _ := d.Get(key).(float32)
return v
}
func (d Data) GetFloat64(key string) float64 {
v, _ := d.Get(key).(float64)
return v
}
func (d Data) GetString(key string) string {
v, _ := d.Get(key).(string)
return v
}
func (d Data) GetByteSlice(key string) []byte {
v, _ := d.Get(key).([]byte)
return v
}
func (d Data) GetStringSlice(key string) []string {
v, _ := d.Get(key).([]string)
return v
}
func (d Data) GetIntSlice(key string) []int {
v, _ := d.Get(key).([]int)
return v
}
func (d Data) GetStringMap(key string) StringMap {
v, _ := d.Get(key).(StringMap)
return v
}
func (d Data) GetData(key string) Data {
v, _ := d.Get(key).(Data)
return v
} | types/data.go | 0.722233 | 0.473657 | data.go | starcoder |
package btree
// https://en.wikipedia.org/wiki/Binary_tree
import (
"github.com/ray-g/goalgos/data-structures/queue"
"github.com/ray-g/goalgos/data-structures/stack"
number "github.com/ray-g/goalgos/math/number-theory"
)
type Node struct {
Value interface{}
Parent *Node
Left, Right *Node
}
func makeNode(value interface{}) *Node {
return &Node{Value: value}
}
type Tree struct {
root *Node
}
func New() *Tree {
t := new(Tree)
return t
}
// Add to the first nil leaf. First is according BFS
func (t *Tree) Add(value interface{}) {
node := makeNode(value)
if t.root == nil {
t.root = node
} else {
added := false
t.BFS(func(n *Node) bool {
if n.Left == nil {
node.Parent = n
n.Left = node
added = true
} else if n.Right == nil {
node.Parent = n
n.Right = node
added = true
}
return added
})
}
}
// Insert follow https://en.wikipedia.org/wiki/Binary_tree#Insertion
func (t *Tree) Insert(value interface{}, at interface{}, toLeft bool) bool {
parent := t.Find(at)
if parent != nil {
node := makeNode(value)
node.Parent = parent
if toLeft {
if parent.Left == nil {
parent.Left = node
} else {
node.Left = parent.Left
node.Left.Parent, parent.Left = node, node
}
} else {
if parent.Right == nil {
parent.Right = node
} else {
node.Right = parent.Right
node.Right.Parent, parent.Right = node, node
}
}
return true
}
return false
}
// Delete follow https://en.wikipedia.org/wiki/Binary_tree#Deletion
func (t *Tree) Delete(value interface{}) (deleted bool) {
deleted = true
node := t.Find(value)
if node == nil {
return
} else if node.Left != nil && node.Right != nil {
// Have both leaves, cannot delete
deleted = false
} else if node.Parent == nil {
// Root
if node.Left != nil {
t.root = node.Left
} else {
t.root = node.Right
}
t.root.Parent = nil
} else {
parent := node.Parent
if node.Left == nil && node.Right == nil {
// Leaf, just delete it
if parent.Left == node {
parent.Left = nil
} else {
parent.Right = nil
}
node.Parent = nil
} else if node.Left != nil {
// Left is not nil
node.Left.Parent = parent
if parent.Left == node {
parent.Left = node.Left
} else {
parent.Right = node.Left
}
node.Parent = nil
} else {
// Right is not nil
node.Right.Parent = parent
if parent.Left == node {
parent.Left = node.Right
} else {
parent.Right = node.Right
}
node.Parent = nil
}
}
return
}
func (t *Tree) Find(value interface{}) *Node {
var node *Node
t.BFS(func(n *Node) bool {
if n.Value == value {
node = n
return true
}
return false
})
return node
}
// BFS Breadth First Search
func (t *Tree) BFS(f func(n *Node) bool) {
if t.root == nil {
return
}
searchQ := queue.New()
searchQ.EnQueue(t.root)
for !searchQ.IsEmpty() {
node := searchQ.DeQueue().(*Node)
if node.Left != nil {
searchQ.EnQueue(node.Left)
}
if node.Right != nil {
searchQ.EnQueue(node.Right)
}
if node == nil || f(node) {
break
}
}
}
// DFS Depth First Search
func (t *Tree) DFSStack(f func(n *Node) bool) {
if t.root == nil {
return
}
t.dfsStack(f)
}
func (t *Tree) DFSRecursive(f func(n *Node) bool) {
if t.root == nil {
return
}
t.root.dfsNext(f)
}
func (t *Tree) dfsStack(f func(n *Node) bool) {
searchS := stack.New()
searchS.Push(t.root)
for !searchS.IsEmpty() {
node := searchS.Pop().(*Node)
if node.Right != nil {
searchS.Push(node.Right)
}
if node.Left != nil {
searchS.Push(node.Left)
}
if node == nil || f(node) {
break
}
}
}
func (n *Node) dfsNext(f func(n *Node) bool) bool {
if f(n) {
return true
}
found := false
if n.Left != nil {
found = n.Left.dfsNext(f)
}
if !found && n.Right != nil {
found = n.Right.dfsNext(f)
}
return found
}
func depth(n *Node) int {
if n == nil {
return 0
}
return 1 + number.Max(depth(n.Left), depth(n.Right))
}
func (t *Tree) Depth() int {
return depth(t.root)
} | data-structures/trees/binary-tree/binary_tree.go | 0.770119 | 0.460713 | binary_tree.go | starcoder |
package utilz
import (
crand "crypto/rand"
"math/big"
mathrand "math/rand"
"strconv"
"time"
)
// Percent calculate what is [percent]% of [number]
// For Example 25% of 200 is 50
// It returns result as float64
func Percent(pcent int64, all int64) float64 {
percent := ((float64(all) * float64(pcent)) / float64(100))
return percent
}
// PercentOf calculate [number1] is what percent of [number2]
// For example 300 is 12.5% of 2400
// It returns result as float64
func PercentOf(current int64, all int64) float64 {
if current == 0 || all == 0 {
return 0.0
}
percent := (float64(current) * float64(100)) / float64(all)
return percent
}
func GetPercent(done int64, all int64) float64 {
if all == 0 || done == 0 {
return 0.0
}
percent := float64(100) / (float64(all) / float64(done))
return percent
}
func GetFormattedPercent(done int64, all int64) string {
percentDone := Sf("%s%%", strconv.FormatFloat(GetPercent(done, all), 'f', 2, 64))
return percentDone
}
// Change calculate what is the percentage increase/decrease from [number1] to [number2]
// For example 60 is 200% increase from 20
// It returns result as float64
func Change(before int64, after int64) float64 {
diff := float64(after) - float64(before)
realDiff := diff / float64(before)
percentDiff := 100 * realDiff
return percentDiff
}
// Generate number range including `from` and `to`.
func GenerateIntRangeInclusive(from, to int) []int {
ints := []int{}
if from <= to {
for i := from; i <= to; i++ {
ints = append(ints, i)
}
} else {
for i := from; i >= to; i-- {
ints = append(ints, i)
}
}
return ints
}
// ReverseIntSlice reverses a slice integers.
func ReverseIntSlice(ss []int) {
last := len(ss) - 1
for i := 0; i < len(ss)/2; i++ {
ss[i], ss[last-i] = ss[last-i], ss[i]
}
}
// NewUniqueInts removes elements that have duplicates in the original or new elements.
func NewUniqueInts(orig []int, add ...int) []int {
var n []int
for _, av := range add {
found := false
s := av
// Check the original slice for duplicates
for _, ov := range orig {
if s == ov {
found = true
break
}
}
// Check that we didn't already add it in
if !found {
for _, nv := range n {
if s == nv {
found = true
break
}
}
}
// If no duplicates were found, add the entry in
if !found {
n = append(n, s)
}
}
return n
}
// UniqueAppendInts behaves like the Go append, but does not add duplicate elements.
func UniqueAppendInts(orig []int, add ...int) []int {
return append(orig, NewUniqueInts(orig, add...)...)
}
func DeduplicateInts(a []int) []int {
var res []int
res = UniqueAppendInts(res, a...)
return res
}
func ShuffleMathRand(n int, swap func(i, j int)) {
if n < 0 {
panic("invalid argument to Shuffle")
}
mathrand.Seed(time.Now().UnixNano())
for i := n - 1; i > 0; i-- { // Fisher-Yates shuffle
j := mathrand.Intn(i + 1)
swap(i, j)
}
}
func ShuffleCryptoRand(n int, swap func(i, j int)) {
if n < 0 {
panic("invalid argument to Shuffle")
}
for i := n - 1; i > 0; i-- { // Fisher-Yates shuffle
jj, err := crand.Int(crand.Reader, big.NewInt(int64(i+1)))
if err != nil {
panic(err)
}
j := jj.Int64()
swap(i, int(j))
}
}
func ShuffleIntSliceMathRand(a []int) {
ShuffleMathRand(len(a), func(i, j int) {
a[i], a[j] = a[j], a[i]
})
}
func ShuffleIntSliceCryptoRand(a []int) {
ShuffleCryptoRand(len(a), func(i, j int) {
a[i], a[j] = a[j], a[i]
})
} | math.go | 0.779028 | 0.461927 | math.go | starcoder |
package types
import (
"bytes"
"encoding/binary"
"encoding/hex"
"fmt"
"io"
"math/bits"
"strconv"
"strings"
)
// A SpendPolicy describes the conditions under which an input may be spent.
type SpendPolicy struct {
Type interface{ isPolicy() }
}
// PolicyTypeAbove requires the input to be spent above a given block height.
type PolicyTypeAbove uint64
// PolicyAbove returns a policy that requires the input to be spent above a
// given block height.
func PolicyAbove(height uint64) SpendPolicy { return SpendPolicy{PolicyTypeAbove(height)} }
// PolicyTypePublicKey requires the input to be signed by a given key.
type PolicyTypePublicKey PublicKey
// PolicyPublicKey returns a policy that requires the input to be signed by a
// given key.
func PolicyPublicKey(pk PublicKey) SpendPolicy { return SpendPolicy{PolicyTypePublicKey(pk)} }
// PolicyTypeThreshold requires at least N sub-policies to be satisfied.
type PolicyTypeThreshold struct {
N uint8
Of []SpendPolicy
}
// PolicyThreshold returns a policy that requires at least N sub-policies to be
// satisfied.
func PolicyThreshold(n uint8, of []SpendPolicy) SpendPolicy {
return SpendPolicy{PolicyTypeThreshold{n, of}}
}
// AnyoneCanSpend returns a policy that has no requirements.
func AnyoneCanSpend() SpendPolicy { return PolicyThreshold(0, nil) }
// PolicyTypeUnlockConditions reproduces the requirements imposed by Sia's
// original "UnlockConditions" type. It exists for compatibility purposes and
// should not be used to construct new policies.
type PolicyTypeUnlockConditions struct {
Timelock uint64
PublicKeys []PublicKey
SignaturesRequired uint8
}
func (PolicyTypeAbove) isPolicy() {}
func (PolicyTypePublicKey) isPolicy() {}
func (PolicyTypeThreshold) isPolicy() {}
func (PolicyTypeUnlockConditions) isPolicy() {}
func (uc PolicyTypeUnlockConditions) root() Hash256 {
buf := make([]byte, 65)
uint64Leaf := func(u uint64) Hash256 {
buf[0] = 0
binary.LittleEndian.PutUint64(buf[1:], u)
return HashBytes(buf[:9])
}
pubkeyLeaf := func(pk PublicKey) Hash256 {
buf[0] = 0
copy(buf[1:], "ed25519\x00\x00\x00\x00\x00\x00\x00\x00\x00")
binary.LittleEndian.PutUint64(buf[17:], uint64(len(pk)))
copy(buf[25:], pk[:])
return HashBytes(buf[:57])
}
nodeHash := func(left, right Hash256) Hash256 {
buf[0] = 1
copy(buf[1:], left[:])
copy(buf[33:], right[:])
return HashBytes(buf[:65])
}
var trees [8]Hash256
var numLeaves uint8
addLeaf := func(h Hash256) {
i := 0
for ; numLeaves&(1<<i) != 0; i++ {
h = nodeHash(trees[i], h)
}
trees[i] = h
numLeaves++
}
treeRoot := func() Hash256 {
i := bits.TrailingZeros8(numLeaves)
root := trees[i]
for i++; i < len(trees); i++ {
if numLeaves&(1<<i) != 0 {
root = nodeHash(trees[i], root)
}
}
return root
}
addLeaf(uint64Leaf(uc.Timelock))
for _, key := range uc.PublicKeys {
addLeaf(pubkeyLeaf(key))
}
addLeaf(uint64Leaf(uint64(uc.SignaturesRequired)))
return treeRoot()
}
// Address computes the opaque address for a given policy.
func (p SpendPolicy) Address() Address {
if uc, ok := p.Type.(PolicyTypeUnlockConditions); ok {
// NOTE: to preserve compatibility, we use the original address
// derivation code for these policies
return Address(uc.root())
}
h := hasherPool.Get().(*Hasher)
defer hasherPool.Put(h)
h.Reset()
h.E.WriteString("sia/address")
p.EncodeTo(h.E)
return Address(h.Sum())
}
// StandardAddress computes the address for a single public key policy.
func StandardAddress(pk PublicKey) Address { return PolicyPublicKey(pk).Address() }
// String implements fmt.Stringer.
func (p SpendPolicy) String() string {
var sb strings.Builder
switch p := p.Type.(type) {
case PolicyTypeAbove:
sb.WriteString("above(")
sb.WriteString(strconv.FormatUint(uint64(p), 10))
sb.WriteByte(')')
case PolicyTypePublicKey:
sb.WriteString("pk(")
sb.WriteString(hex.EncodeToString(p[:]))
sb.WriteByte(')')
case PolicyTypeThreshold:
sb.WriteString("thresh(")
sb.WriteString(strconv.FormatUint(uint64(p.N), 10))
sb.WriteString(",[")
for i, sp := range p.Of {
if i > 0 {
sb.WriteByte(',')
}
sb.WriteString(sp.String())
}
sb.WriteString("])")
case PolicyTypeUnlockConditions:
sb.WriteString("uc(")
sb.WriteString(strconv.FormatUint(p.Timelock, 10))
sb.WriteString(",[")
for i, pk := range p.PublicKeys {
if i > 0 {
sb.WriteByte(',')
}
sb.WriteString(hex.EncodeToString(pk[:]))
}
sb.WriteString("],")
sb.WriteString(strconv.FormatUint(uint64(p.SignaturesRequired), 10))
sb.WriteByte(')')
}
return sb.String()
}
// ParseSpendPolicy parses a spend policy from a string.
func ParseSpendPolicy(s string) (SpendPolicy, error) {
var err error // sticky
nextToken := func() string {
s = strings.TrimSpace(s)
i := strings.IndexAny(s, "(),[]")
if err != nil || i == -1 {
return ""
}
t := s[:i]
s = s[i:]
return t
}
consume := func(b byte) {
if err != nil {
return
}
s = strings.TrimSpace(s)
if len(s) == 0 {
err = io.ErrUnexpectedEOF
} else if s[0] != b {
err = fmt.Errorf("expected %q, got %q", b, s[0])
} else {
s = s[1:]
}
}
peek := func() byte {
if err != nil || len(s) == 0 {
return 0
}
return s[0]
}
parseInt := func(bitSize int) (u uint64) {
t := nextToken()
if err != nil {
return 0
}
u, err = strconv.ParseUint(t, 10, bitSize)
return
}
parsePubkey := func() (pk PublicKey) {
t := nextToken()
if err != nil {
return
} else if len(t) != 64 {
err = fmt.Errorf("invalid pubkey length (%d)", len(t))
return
}
_, err = hex.Decode(pk[:], []byte(t))
return
}
var parseSpendPolicy func() SpendPolicy
parseSpendPolicy = func() SpendPolicy {
typ := nextToken()
consume('(')
defer consume(')')
switch typ {
case "above":
return PolicyAbove(parseInt(64))
case "pk":
return PolicyPublicKey(parsePubkey())
case "thresh":
n := parseInt(8)
consume(',')
consume('[')
var of []SpendPolicy
for err == nil && peek() != ']' {
of = append(of, parseSpendPolicy())
if peek() != ']' {
consume(',')
}
}
consume(']')
return PolicyThreshold(uint8(n), of)
case "uc":
timelock := parseInt(64)
consume(',')
consume('[')
var pks []PublicKey
for err == nil && peek() != ']' {
pks = append(pks, parsePubkey())
if peek() != ']' {
consume(',')
}
}
consume(']')
consume(',')
sigsRequired := parseInt(8)
return SpendPolicy{
PolicyTypeUnlockConditions{
Timelock: timelock,
PublicKeys: pks,
SignaturesRequired: uint8(sigsRequired),
},
}
default:
if err == nil {
err = fmt.Errorf("unrecognized policy type %q", typ)
}
return SpendPolicy{}
}
}
p := parseSpendPolicy()
if err == nil && len(s) > 0 {
err = fmt.Errorf("trailing bytes: %q", s)
}
return p, err
}
// MarshalText implements encoding.TextMarshaler.
func (p SpendPolicy) MarshalText() ([]byte, error) {
return []byte(p.String()), nil
}
// UnmarshalText implements encoding.TextUnmarshaler.
func (p *SpendPolicy) UnmarshalText(b []byte) (err error) {
*p, err = ParseSpendPolicy(string(b))
return
}
// MarshalJSON implements json.Marshaler.
func (p SpendPolicy) MarshalJSON() ([]byte, error) {
return []byte(`"` + p.String() + `"`), nil
}
// UnmarshalJSON implements json.Unmarshaler.
func (p *SpendPolicy) UnmarshalJSON(b []byte) (err error) {
return p.UnmarshalText(bytes.Trim(b, `"`))
} | types/policy.go | 0.676834 | 0.441011 | policy.go | starcoder |
package mathh
// RoundFloat32ToInt returns nearest int for given float32.
func RoundFloat32ToInt(f float32) int {
const d = 0.5
switch {
case IsNaNFloat32(f):
return 0
case f < MinInt+d:
return MinInt
case f > MaxInt-d:
return MaxInt
case f < d && f > -d:
return 0
case f > 0:
return int(f + d)
default:
return int(f - d)
}
}
// RoundFloat32ToInt8 returns nearest int8 for given float32.
func RoundFloat32ToInt8(f float32) int8 {
const d = 0.5
switch {
case IsNaNFloat32(f):
return 0
case f < MinInt8+d:
return MinInt8
case f > MaxInt8-d:
return MaxInt8
case f < d && f > -d:
return 0
case f > 0:
return int8(f + d)
default:
return int8(f - d)
}
}
// RoundFloat32ToInt16 returns nearest int16 for given float32.
func RoundFloat32ToInt16(f float32) int16 {
const d = 0.5
switch {
case IsNaNFloat32(f):
return 0
case f < MinInt16+d:
return MinInt16
case f > MaxInt16-d:
return MaxInt16
case f < d && f > -d:
return 0
case f > 0:
return int16(f + d)
default:
return int16(f - d)
}
}
// RoundFloat32ToInt32 returns nearest int32 for given float32.
func RoundFloat32ToInt32(f float32) int32 {
const d = 0.5
switch {
case IsNaNFloat32(f):
return 0
case f < MinInt32+d:
return MinInt32
case f > MaxInt32-d:
return MaxInt32
case f < d && f > -d:
return 0
case f > 0:
return int32(f + d)
default:
return int32(f - d)
}
}
// RoundFloat64ToInt64 returns nearest int64 for given float64.
func RoundFloat64ToInt64(f float64) int64 {
const d = 0.5
switch {
case IsNaNFloat64(f):
return 0
case f < MinInt64+d:
return MinInt64
case f > MaxInt64-d:
return MaxInt64
case f < d && f > -d:
return 0
case f > 0:
return int64(f + d)
default:
return int64(f - d)
}
}
// RoundFloat64ToInt returns nearest int for given float64.
func RoundFloat64ToInt(f float64) int {
const d = 0.5
switch {
case IsNaNFloat64(f):
return 0
case f < MinInt+d:
return MinInt
case f > MaxInt-d:
return MaxInt
case f < d && f > -d:
return 0
case f > 0:
return int(f + d)
default:
return int(f - d)
}
}
// RoundFloat64ToInt8 returns nearest int8 for given float64.
func RoundFloat64ToInt8(f float64) int8 {
const d = 0.5
switch {
case IsNaNFloat64(f):
return 0
case f < MinInt8+d:
return MinInt8
case f > MaxInt8-d:
return MaxInt8
case f < d && f > -d:
return 0
case f > 0:
return int8(f + d)
default:
return int8(f - d)
}
}
// RoundFloat64ToInt16 returns nearest int16 for given float64.
func RoundFloat64ToInt16(f float64) int16 {
const d = 0.5
switch {
case IsNaNFloat64(f):
return 0
case f < MinInt16+d:
return MinInt16
case f > MaxInt16-d:
return MaxInt16
case f < d && f > -d:
return 0
case f > 0:
return int16(f + d)
default:
return int16(f - d)
}
}
// RoundFloat64ToInt32 returns nearest int32 for given float64.
func RoundFloat64ToInt32(f float64) int32 {
const d = 0.5
switch {
case IsNaNFloat64(f):
return 0
case f < MinInt32+d:
return MinInt32
case f > MaxInt32-d:
return MaxInt32
case f < d && f > -d:
return 0
case f > 0:
return int32(f + d)
default:
return int32(f - d)
}
}
// RoundFloat32ToUint returns nearest int64 for given float32.
func RoundFloat32ToUint(f float32) uint {
const d = 0.5
switch {
case IsNaNFloat32(f):
return 0
case f < 0:
return 0
case f > MaxUint-d:
return MaxUint
default:
return uint(f + d)
}
}
// RoundFloat32ToUint8 returns nearest int64 for given float32.
func RoundFloat32ToUint8(f float32) uint8 {
const d = 0.5
switch {
case IsNaNFloat32(f):
return 0
case f < 0:
return 0
case f > MaxUint8-d:
return MaxUint8
default:
return uint8(f + d)
}
}
// RoundFloat32ToUint16 returns nearest int64 for given float32.
func RoundFloat32ToUint16(f float32) uint16 {
const d = 0.5
switch {
case IsNaNFloat32(f):
return 0
case f < 0:
return 0
case f > MaxUint16-d:
return MaxUint16
default:
return uint16(f + d)
}
}
// RoundFloat32ToUint32 returns nearest int64 for given float32.
func RoundFloat32ToUint32(f float32) uint32 {
const d = 0.5
switch {
case IsNaNFloat32(f):
return 0
case f < 0:
return 0
case f > MaxUint32-d:
return MaxUint32
default:
return uint32(f + d)
}
}
// RoundFloat64ToUint64 returns nearest int64 for given float64.
func RoundFloat64ToUint64(f float64) uint64 {
const d = 0.5
switch {
case IsNaNFloat64(f):
return 0
case f < 0:
return 0
case f > MaxUint64-d:
return MaxUint64
default:
return uint64(f + d)
}
}
// RoundFloat64ToUint returns nearest int64 for given float64.
func RoundFloat64ToUint(f float64) uint {
const d = 0.5
switch {
case IsNaNFloat64(f):
return 0
case f < 0:
return 0
case f > MaxUint-d:
return MaxUint
default:
return uint(f + d)
}
}
// RoundFloat64ToUint8 returns nearest int64 for given float64.
func RoundFloat64ToUint8(f float64) uint8 {
const d = 0.5
switch {
case IsNaNFloat64(f):
return 0
case f < 0:
return 0
case f > MaxUint8-d:
return MaxUint8
default:
return uint8(f + d)
}
}
// RoundFloat64ToUint16 returns nearest int64 for given float64.
func RoundFloat64ToUint16(f float64) uint16 {
const d = 0.5
switch {
case IsNaNFloat64(f):
return 0
case f < 0:
return 0
case f > MaxUint16-d:
return MaxUint16
default:
return uint16(f + d)
}
}
// RoundFloat64ToUint32 returns nearest int64 for given float64.
func RoundFloat64ToUint32(f float64) uint32 {
const d = 0.5
switch {
case IsNaNFloat64(f):
return 0
case f < 0:
return 0
case f > MaxUint32-d:
return MaxUint32
default:
return uint32(f + d)
}
} | back/vendor/github.com/apaxa-go/helper/mathh/float-round-gen.go | 0.799325 | 0.546738 | float-round-gen.go | starcoder |
package counting_elements
/*
You are given N counters, initially set to 0, and you have two possible operations on them:
increase(X) − counter X is increased by 1,
max counter − all counters are set to the maximum value of any counter.
A non-empty zero-indexed array A of M integers is given. This array represents consecutive operations:
if A[K] = X, such that 1 ≤ X ≤ N, then operation K is increase(X),
if A[K] = N + 1 then operation K is max counter.
For example, given integer N = 5 and array A such that:
A[0] = 3
A[1] = 4
A[2] = 4
A[3] = 6
A[4] = 1
A[5] = 4
A[6] = 4
the values of the counters after each consecutive operation will be:
(0, 0, 1, 0, 0)
(0, 0, 1, 1, 0)
(0, 0, 1, 2, 0)
(2, 2, 2, 2, 2)
(3, 2, 2, 2, 2)
(3, 2, 2, 3, 2)
(3, 2, 2, 4, 2)
The goal is to calculate the value of every counter after all operations.
Write a function:
func Solution(N int, A []int) []int
that, given an integer N and a non-empty zero-indexed array A consisting of M integers, returns a sequence of
integers representing the values of the counters.
The sequence should be returned as:
a structure Results (in C), or
a vector of integers (in C++), or
a record Results (in Pascal), or
an array of integers (in any other programming language).
For example, given:
A[0] = 3
A[1] = 4
A[2] = 4
A[3] = 6
A[4] = 1
A[5] = 4
A[6] = 4
the function should return [3, 2, 2, 4, 2], as explained above.
Assume that:
N and M are integers within the range [1..100,000];
each element of array A is an integer within the range [1..N + 1].
Complexity:
expected worst-case time complexity is O(N+M);
expected worst-case space complexity is O(N), beyond input storage
(not counting the storage required for input arguments).
*/
func MaxCounters(N int, A []int) []int {
maxNum := N + 1
base := 0
currentMax := 0
result := make([]int, N)
for _, value := range(A) {
if value == maxNum {
base = currentMax
} else {
if result[value-1] < base {
result[value-1] = base
}
result[value-1] +=1
if currentMax < result[value-1] {
currentMax = result[value-1]
}
}
}
for idx, value := range(result) {
if value < base {
result[idx] = base
}
}
return result
} | counting-elements/MaxCounters.go | 0.840586 | 0.773088 | MaxCounters.go | starcoder |
package onshape
import (
"encoding/json"
)
// BTEllipseDescription866 struct for BTEllipseDescription866
type BTEllipseDescription866 struct {
BTCurveDescription1583
BtType *string `json:"btType,omitempty"`
MajorAxis *BTVector3d389 `json:"majorAxis,omitempty"`
MajorRadius *float64 `json:"majorRadius,omitempty"`
MinorRadius *float64 `json:"minorRadius,omitempty"`
Normal *BTVector3d389 `json:"normal,omitempty"`
Origin *BTVector3d389 `json:"origin,omitempty"`
}
// NewBTEllipseDescription866 instantiates a new BTEllipseDescription866 object
// This constructor will assign default values to properties that have it defined,
// and makes sure properties required by API are set, but the set of arguments
// will change when the set of required properties is changed
func NewBTEllipseDescription866() *BTEllipseDescription866 {
this := BTEllipseDescription866{}
return &this
}
// NewBTEllipseDescription866WithDefaults instantiates a new BTEllipseDescription866 object
// This constructor will only assign default values to properties that have it defined,
// but it doesn't guarantee that properties required by API are set
func NewBTEllipseDescription866WithDefaults() *BTEllipseDescription866 {
this := BTEllipseDescription866{}
return &this
}
// GetBtType returns the BtType field value if set, zero value otherwise.
func (o *BTEllipseDescription866) GetBtType() string {
if o == nil || o.BtType == nil {
var ret string
return ret
}
return *o.BtType
}
// GetBtTypeOk returns a tuple with the BtType field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *BTEllipseDescription866) GetBtTypeOk() (*string, bool) {
if o == nil || o.BtType == nil {
return nil, false
}
return o.BtType, true
}
// HasBtType returns a boolean if a field has been set.
func (o *BTEllipseDescription866) HasBtType() bool {
if o != nil && o.BtType != nil {
return true
}
return false
}
// SetBtType gets a reference to the given string and assigns it to the BtType field.
func (o *BTEllipseDescription866) SetBtType(v string) {
o.BtType = &v
}
// GetMajorAxis returns the MajorAxis field value if set, zero value otherwise.
func (o *BTEllipseDescription866) GetMajorAxis() BTVector3d389 {
if o == nil || o.MajorAxis == nil {
var ret BTVector3d389
return ret
}
return *o.MajorAxis
}
// GetMajorAxisOk returns a tuple with the MajorAxis field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *BTEllipseDescription866) GetMajorAxisOk() (*BTVector3d389, bool) {
if o == nil || o.MajorAxis == nil {
return nil, false
}
return o.MajorAxis, true
}
// HasMajorAxis returns a boolean if a field has been set.
func (o *BTEllipseDescription866) HasMajorAxis() bool {
if o != nil && o.MajorAxis != nil {
return true
}
return false
}
// SetMajorAxis gets a reference to the given BTVector3d389 and assigns it to the MajorAxis field.
func (o *BTEllipseDescription866) SetMajorAxis(v BTVector3d389) {
o.MajorAxis = &v
}
// GetMajorRadius returns the MajorRadius field value if set, zero value otherwise.
func (o *BTEllipseDescription866) GetMajorRadius() float64 {
if o == nil || o.MajorRadius == nil {
var ret float64
return ret
}
return *o.MajorRadius
}
// GetMajorRadiusOk returns a tuple with the MajorRadius field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *BTEllipseDescription866) GetMajorRadiusOk() (*float64, bool) {
if o == nil || o.MajorRadius == nil {
return nil, false
}
return o.MajorRadius, true
}
// HasMajorRadius returns a boolean if a field has been set.
func (o *BTEllipseDescription866) HasMajorRadius() bool {
if o != nil && o.MajorRadius != nil {
return true
}
return false
}
// SetMajorRadius gets a reference to the given float64 and assigns it to the MajorRadius field.
func (o *BTEllipseDescription866) SetMajorRadius(v float64) {
o.MajorRadius = &v
}
// GetMinorRadius returns the MinorRadius field value if set, zero value otherwise.
func (o *BTEllipseDescription866) GetMinorRadius() float64 {
if o == nil || o.MinorRadius == nil {
var ret float64
return ret
}
return *o.MinorRadius
}
// GetMinorRadiusOk returns a tuple with the MinorRadius field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *BTEllipseDescription866) GetMinorRadiusOk() (*float64, bool) {
if o == nil || o.MinorRadius == nil {
return nil, false
}
return o.MinorRadius, true
}
// HasMinorRadius returns a boolean if a field has been set.
func (o *BTEllipseDescription866) HasMinorRadius() bool {
if o != nil && o.MinorRadius != nil {
return true
}
return false
}
// SetMinorRadius gets a reference to the given float64 and assigns it to the MinorRadius field.
func (o *BTEllipseDescription866) SetMinorRadius(v float64) {
o.MinorRadius = &v
}
// GetNormal returns the Normal field value if set, zero value otherwise.
func (o *BTEllipseDescription866) GetNormal() BTVector3d389 {
if o == nil || o.Normal == nil {
var ret BTVector3d389
return ret
}
return *o.Normal
}
// GetNormalOk returns a tuple with the Normal field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *BTEllipseDescription866) GetNormalOk() (*BTVector3d389, bool) {
if o == nil || o.Normal == nil {
return nil, false
}
return o.Normal, true
}
// HasNormal returns a boolean if a field has been set.
func (o *BTEllipseDescription866) HasNormal() bool {
if o != nil && o.Normal != nil {
return true
}
return false
}
// SetNormal gets a reference to the given BTVector3d389 and assigns it to the Normal field.
func (o *BTEllipseDescription866) SetNormal(v BTVector3d389) {
o.Normal = &v
}
// GetOrigin returns the Origin field value if set, zero value otherwise.
func (o *BTEllipseDescription866) GetOrigin() BTVector3d389 {
if o == nil || o.Origin == nil {
var ret BTVector3d389
return ret
}
return *o.Origin
}
// GetOriginOk returns a tuple with the Origin field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *BTEllipseDescription866) GetOriginOk() (*BTVector3d389, bool) {
if o == nil || o.Origin == nil {
return nil, false
}
return o.Origin, true
}
// HasOrigin returns a boolean if a field has been set.
func (o *BTEllipseDescription866) HasOrigin() bool {
if o != nil && o.Origin != nil {
return true
}
return false
}
// SetOrigin gets a reference to the given BTVector3d389 and assigns it to the Origin field.
func (o *BTEllipseDescription866) SetOrigin(v BTVector3d389) {
o.Origin = &v
}
func (o BTEllipseDescription866) MarshalJSON() ([]byte, error) {
toSerialize := map[string]interface{}{}
serializedBTCurveDescription1583, errBTCurveDescription1583 := json.Marshal(o.BTCurveDescription1583)
if errBTCurveDescription1583 != nil {
return []byte{}, errBTCurveDescription1583
}
errBTCurveDescription1583 = json.Unmarshal([]byte(serializedBTCurveDescription1583), &toSerialize)
if errBTCurveDescription1583 != nil {
return []byte{}, errBTCurveDescription1583
}
if o.BtType != nil {
toSerialize["btType"] = o.BtType
}
if o.MajorAxis != nil {
toSerialize["majorAxis"] = o.MajorAxis
}
if o.MajorRadius != nil {
toSerialize["majorRadius"] = o.MajorRadius
}
if o.MinorRadius != nil {
toSerialize["minorRadius"] = o.MinorRadius
}
if o.Normal != nil {
toSerialize["normal"] = o.Normal
}
if o.Origin != nil {
toSerialize["origin"] = o.Origin
}
return json.Marshal(toSerialize)
}
type NullableBTEllipseDescription866 struct {
value *BTEllipseDescription866
isSet bool
}
func (v NullableBTEllipseDescription866) Get() *BTEllipseDescription866 {
return v.value
}
func (v *NullableBTEllipseDescription866) Set(val *BTEllipseDescription866) {
v.value = val
v.isSet = true
}
func (v NullableBTEllipseDescription866) IsSet() bool {
return v.isSet
}
func (v *NullableBTEllipseDescription866) Unset() {
v.value = nil
v.isSet = false
}
func NewNullableBTEllipseDescription866(val *BTEllipseDescription866) *NullableBTEllipseDescription866 {
return &NullableBTEllipseDescription866{value: val, isSet: true}
}
func (v NullableBTEllipseDescription866) MarshalJSON() ([]byte, error) {
return json.Marshal(v.value)
}
func (v *NullableBTEllipseDescription866) UnmarshalJSON(src []byte) error {
v.isSet = true
return json.Unmarshal(src, &v.value)
} | onshape/model_bt_ellipse_description_866.go | 0.803212 | 0.456591 | model_bt_ellipse_description_866.go | starcoder |
package instanceselector
const azureInstanceJson = `
{
"France Central": [
{
"baseline": 1.0,
"generation": "current",
"price": 0.022,
"burstable": false,
"instanceType": "Standard_A0",
"memory": 0.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.026,
"burstable": false,
"instanceType": "Standard_A1",
"memory": 1.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.132,
"burstable": false,
"instanceType": "Standard_A2",
"memory": 3.5,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.224,
"burstable": false,
"instanceType": "Standard_A3",
"memory": 7.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.297,
"burstable": false,
"instanceType": "Standard_A5",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.528,
"burstable": false,
"instanceType": "Standard_A4",
"memory": 14.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.594,
"burstable": false,
"instanceType": "Standard_A6",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.188,
"burstable": false,
"instanceType": "Standard_A7",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.088,
"burstable": false,
"instanceType": "Standard_D1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.175,
"burstable": false,
"instanceType": "Standard_D2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.351,
"burstable": false,
"instanceType": "Standard_D3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.702,
"burstable": false,
"instanceType": "Standard_D4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.404,
"burstable": false,
"instanceType": "Standard_D5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.234,
"burstable": false,
"instanceType": "Standard_D11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.469,
"burstable": false,
"instanceType": "Standard_D12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.937,
"burstable": false,
"instanceType": "Standard_D13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.874,
"burstable": false,
"instanceType": "Standard_D14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.343,
"burstable": false,
"instanceType": "Standard_D15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.175,
"burstable": false,
"instanceType": "Standard_D2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.351,
"burstable": false,
"instanceType": "Standard_D3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.702,
"burstable": false,
"instanceType": "Standard_D4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.404,
"burstable": false,
"instanceType": "Standard_D5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.234,
"burstable": false,
"instanceType": "Standard_D11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.469,
"burstable": false,
"instanceType": "Standard_D12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.937,
"burstable": false,
"instanceType": "Standard_D13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.874,
"burstable": false,
"instanceType": "Standard_D14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.05,
"burstable": false,
"instanceType": "Standard_F1",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.101,
"burstable": false,
"instanceType": "Standard_F2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.202,
"burstable": false,
"instanceType": "Standard_F4",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.404,
"burstable": false,
"instanceType": "Standard_F8",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.808,
"burstable": false,
"instanceType": "Standard_F16",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.05,
"burstable": false,
"instanceType": "Standard_A1_v2",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.178,
"burstable": false,
"instanceType": "Standard_A2m_v2",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.106,
"burstable": false,
"instanceType": "Standard_A2_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.374,
"burstable": false,
"instanceType": "Standard_A4m_v2",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.222,
"burstable": false,
"instanceType": "Standard_A4_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.786,
"burstable": false,
"instanceType": "Standard_A8m_v2",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.467,
"burstable": false,
"instanceType": "Standard_A8_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 0.2,
"generation": "current",
"price": 0.026,
"burstable": true,
"instanceType": "Standard_B1ms",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 0.1,
"generation": "current",
"price": 0.013,
"burstable": true,
"instanceType": "Standard_B1s",
"memory": 1.0,
"cpu": 1
},
{
"baseline": 0.6,
"generation": "current",
"price": 0.104,
"burstable": true,
"instanceType": "Standard_B2ms",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 0.4,
"generation": "current",
"price": 0.052,
"burstable": true,
"instanceType": "Standard_B2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 0.9,
"generation": "current",
"price": 0.208,
"burstable": true,
"instanceType": "Standard_B4ms",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.35,
"generation": "current",
"price": 0.416,
"burstable": true,
"instanceType": "Standard_B8ms",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.088,
"burstable": false,
"instanceType": "Standard_DS1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.175,
"burstable": false,
"instanceType": "Standard_DS2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.351,
"burstable": false,
"instanceType": "Standard_DS3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.702,
"burstable": false,
"instanceType": "Standard_DS4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.404,
"burstable": false,
"instanceType": "Standard_DS5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.234,
"burstable": false,
"instanceType": "Standard_DS11-1_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.234,
"burstable": false,
"instanceType": "Standard_DS11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.469,
"burstable": false,
"instanceType": "Standard_DS12-1_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.469,
"burstable": false,
"instanceType": "Standard_DS12-2_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.469,
"burstable": false,
"instanceType": "Standard_DS12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.937,
"burstable": false,
"instanceType": "Standard_DS13-2_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.937,
"burstable": false,
"instanceType": "Standard_DS13-4_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.937,
"burstable": false,
"instanceType": "Standard_DS13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.874,
"burstable": false,
"instanceType": "Standard_DS14-4_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.874,
"burstable": false,
"instanceType": "Standard_DS14-8_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.874,
"burstable": false,
"instanceType": "Standard_DS14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.175,
"burstable": false,
"instanceType": "Standard_DS2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.351,
"burstable": false,
"instanceType": "Standard_DS3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.702,
"burstable": false,
"instanceType": "Standard_DS4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.404,
"burstable": false,
"instanceType": "Standard_DS5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.234,
"burstable": false,
"instanceType": "Standard_DS11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.469,
"burstable": false,
"instanceType": "Standard_DS12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.937,
"burstable": false,
"instanceType": "Standard_DS13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.874,
"burstable": false,
"instanceType": "Standard_DS14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.05,
"burstable": false,
"instanceType": "Standard_F1s",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.101,
"burstable": false,
"instanceType": "Standard_F2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.202,
"burstable": false,
"instanceType": "Standard_F4s",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.404,
"burstable": false,
"instanceType": "Standard_F8s",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.808,
"burstable": false,
"instanceType": "Standard_F16s",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.112,
"burstable": false,
"instanceType": "Standard_D2_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.224,
"burstable": false,
"instanceType": "Standard_D4_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.448,
"burstable": false,
"instanceType": "Standard_D8_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.896,
"burstable": false,
"instanceType": "Standard_D16_v3",
"memory": 64.1,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.792,
"burstable": false,
"instanceType": "Standard_D32_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.584,
"burstable": false,
"instanceType": "Standard_D64_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.112,
"burstable": false,
"instanceType": "Standard_D2s_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.224,
"burstable": false,
"instanceType": "Standard_D4s_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.448,
"burstable": false,
"instanceType": "Standard_D8s_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.896,
"burstable": false,
"instanceType": "Standard_D16s_v3",
"memory": 64.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.792,
"burstable": false,
"instanceType": "Standard_D32s_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.584,
"burstable": false,
"instanceType": "Standard_D64s_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.156,
"burstable": false,
"instanceType": "Standard_E2_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.312,
"burstable": false,
"instanceType": "Standard_E4_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.624,
"burstable": false,
"instanceType": "Standard_E8_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.248,
"burstable": false,
"instanceType": "Standard_E16_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.56,
"burstable": false,
"instanceType": "Standard_E20_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.496,
"burstable": false,
"instanceType": "Standard_E32_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.488,
"burstable": false,
"instanceType": "Standard_E64i_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.488,
"burstable": false,
"instanceType": "Standard_E64_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.156,
"burstable": false,
"instanceType": "Standard_E2s_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.312,
"burstable": false,
"instanceType": "Standard_E4s_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.624,
"burstable": false,
"instanceType": "Standard_E8s_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.248,
"burstable": false,
"instanceType": "Standard_E16s_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.56,
"burstable": false,
"instanceType": "Standard_E20s_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.496,
"burstable": false,
"instanceType": "Standard_E32s_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.488,
"burstable": false,
"instanceType": "Standard_E64is_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.488,
"burstable": false,
"instanceType": "Standard_E64s_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.101,
"burstable": false,
"instanceType": "Standard_F2s_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.202,
"burstable": false,
"instanceType": "Standard_F4s_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.404,
"burstable": false,
"instanceType": "Standard_F8s_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.808,
"burstable": false,
"instanceType": "Standard_F16s_v2",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.616,
"burstable": false,
"instanceType": "Standard_F32s_v2",
"memory": 64.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.232,
"burstable": false,
"instanceType": "Standard_F64s_v2",
"memory": 128.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.636,
"burstable": false,
"instanceType": "Standard_F72s_v2",
"memory": 144.0,
"cpu": 72
}
],
"East US 2": [
{
"baseline": 1.0,
"generation": "current",
"price": 0.02,
"burstable": false,
"instanceType": "Standard_A0",
"memory": 0.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.06,
"burstable": false,
"instanceType": "Standard_A1",
"memory": 1.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.12,
"burstable": false,
"instanceType": "Standard_A2",
"memory": 3.5,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.24,
"burstable": false,
"instanceType": "Standard_A3",
"memory": 7.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.22,
"burstable": false,
"instanceType": "Standard_A5",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.48,
"burstable": false,
"instanceType": "Standard_A4",
"memory": 14.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.44,
"burstable": false,
"instanceType": "Standard_A6",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.88,
"burstable": false,
"instanceType": "Standard_A7",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.057,
"burstable": false,
"instanceType": "Standard_D1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.114,
"burstable": false,
"instanceType": "Standard_D2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.229,
"burstable": false,
"instanceType": "Standard_D3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.458,
"burstable": false,
"instanceType": "Standard_D4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.916,
"burstable": false,
"instanceType": "Standard_D5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.149,
"burstable": false,
"instanceType": "Standard_D11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.299,
"burstable": false,
"instanceType": "Standard_D12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.598,
"burstable": false,
"instanceType": "Standard_D13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.196,
"burstable": false,
"instanceType": "Standard_D14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.495,
"burstable": false,
"instanceType": "Standard_D15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.114,
"burstable": false,
"instanceType": "Standard_D2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.229,
"burstable": false,
"instanceType": "Standard_D3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.458,
"burstable": false,
"instanceType": "Standard_D4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.916,
"burstable": false,
"instanceType": "Standard_D5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.149,
"burstable": false,
"instanceType": "Standard_D11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.299,
"burstable": false,
"instanceType": "Standard_D12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.598,
"burstable": false,
"instanceType": "Standard_D13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.196,
"burstable": false,
"instanceType": "Standard_D14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.05,
"burstable": false,
"instanceType": "Standard_F1",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.099,
"burstable": false,
"instanceType": "Standard_F2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.199,
"burstable": false,
"instanceType": "Standard_F4",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.398,
"burstable": false,
"instanceType": "Standard_F8",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.796,
"burstable": false,
"instanceType": "Standard_F16",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.043,
"burstable": false,
"instanceType": "Standard_A1_v2",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.119,
"burstable": false,
"instanceType": "Standard_A2m_v2",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.091,
"burstable": false,
"instanceType": "Standard_A2_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.249,
"burstable": false,
"instanceType": "Standard_A4m_v2",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.191,
"burstable": false,
"instanceType": "Standard_A4_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.524,
"burstable": false,
"instanceType": "Standard_A8m_v2",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.4,
"burstable": false,
"instanceType": "Standard_A8_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.096,
"burstable": false,
"instanceType": "Standard_D2_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.192,
"burstable": false,
"instanceType": "Standard_D4_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.384,
"burstable": false,
"instanceType": "Standard_D8_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.768,
"burstable": false,
"instanceType": "Standard_D16_v3",
"memory": 64.1,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.536,
"burstable": false,
"instanceType": "Standard_D32_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 0.2,
"generation": "current",
"price": 0.0208,
"burstable": true,
"instanceType": "Standard_B1ms",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 0.1,
"generation": "current",
"price": 0.0104,
"burstable": true,
"instanceType": "Standard_B1s",
"memory": 1.0,
"cpu": 1
},
{
"baseline": 0.6,
"generation": "current",
"price": 0.0832,
"burstable": true,
"instanceType": "Standard_B2ms",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 0.4,
"generation": "current",
"price": 0.0416,
"burstable": true,
"instanceType": "Standard_B2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 0.9,
"generation": "current",
"price": 0.166,
"burstable": true,
"instanceType": "Standard_B4ms",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.35,
"generation": "current",
"price": 0.333,
"burstable": true,
"instanceType": "Standard_B8ms",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.057,
"burstable": false,
"instanceType": "Standard_DS1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.114,
"burstable": false,
"instanceType": "Standard_DS2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.229,
"burstable": false,
"instanceType": "Standard_DS3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.458,
"burstable": false,
"instanceType": "Standard_DS4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.916,
"burstable": false,
"instanceType": "Standard_DS5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.149,
"burstable": false,
"instanceType": "Standard_DS11-1_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.149,
"burstable": false,
"instanceType": "Standard_DS11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.299,
"burstable": false,
"instanceType": "Standard_DS12-1_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.299,
"burstable": false,
"instanceType": "Standard_DS12-2_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.299,
"burstable": false,
"instanceType": "Standard_DS12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.598,
"burstable": false,
"instanceType": "Standard_DS13-2_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.598,
"burstable": false,
"instanceType": "Standard_DS13-4_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.598,
"burstable": false,
"instanceType": "Standard_DS13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.196,
"burstable": false,
"instanceType": "Standard_DS14-4_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.196,
"burstable": false,
"instanceType": "Standard_DS14-8_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.196,
"burstable": false,
"instanceType": "Standard_DS14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.114,
"burstable": false,
"instanceType": "Standard_DS2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.229,
"burstable": false,
"instanceType": "Standard_DS3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.458,
"burstable": false,
"instanceType": "Standard_DS4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.916,
"burstable": false,
"instanceType": "Standard_DS5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.149,
"burstable": false,
"instanceType": "Standard_DS11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.299,
"burstable": false,
"instanceType": "Standard_DS12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.598,
"burstable": false,
"instanceType": "Standard_DS13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.196,
"burstable": false,
"instanceType": "Standard_DS14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.05,
"burstable": false,
"instanceType": "Standard_F1s",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.099,
"burstable": false,
"instanceType": "Standard_F2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.199,
"burstable": false,
"instanceType": "Standard_F4s",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.398,
"burstable": false,
"instanceType": "Standard_F8s",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.796,
"burstable": false,
"instanceType": "Standard_F16s",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.072,
"burstable": false,
"instanceType": "Standard_D64_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.096,
"burstable": false,
"instanceType": "Standard_D2s_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.192,
"burstable": false,
"instanceType": "Standard_D4s_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.384,
"burstable": false,
"instanceType": "Standard_D8s_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.768,
"burstable": false,
"instanceType": "Standard_D16s_v3",
"memory": 64.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.536,
"burstable": false,
"instanceType": "Standard_D32s_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.072,
"burstable": false,
"instanceType": "Standard_D64s_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.133,
"burstable": false,
"instanceType": "Standard_E2_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.266,
"burstable": false,
"instanceType": "Standard_E4_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.532,
"burstable": false,
"instanceType": "Standard_E8_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.064,
"burstable": false,
"instanceType": "Standard_E16_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.46,
"burstable": false,
"instanceType": "Standard_E20_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.128,
"burstable": false,
"instanceType": "Standard_E32_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.629,
"burstable": false,
"instanceType": "Standard_E64i_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.629,
"burstable": false,
"instanceType": "Standard_E64_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.133,
"burstable": false,
"instanceType": "Standard_E2s_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.266,
"burstable": false,
"instanceType": "Standard_E4s_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.532,
"burstable": false,
"instanceType": "Standard_E8s_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.064,
"burstable": false,
"instanceType": "Standard_E16s_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.46,
"burstable": false,
"instanceType": "Standard_E20s_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.128,
"burstable": false,
"instanceType": "Standard_E32s_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.629,
"burstable": false,
"instanceType": "Standard_E64is_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.629,
"burstable": false,
"instanceType": "Standard_E64s_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.495,
"burstable": false,
"instanceType": "Standard_DS15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.067,
"burstable": false,
"instanceType": "Standard_D1",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.134,
"burstable": false,
"instanceType": "Standard_D2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.268,
"burstable": false,
"instanceType": "Standard_D3",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.536,
"burstable": false,
"instanceType": "Standard_D4",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.173,
"burstable": false,
"instanceType": "Standard_D11",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.347,
"burstable": false,
"instanceType": "Standard_D12",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.694,
"burstable": false,
"instanceType": "Standard_D13",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.387,
"burstable": false,
"instanceType": "Standard_D14",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.06,
"burstable": false,
"instanceType": "Standard_NC6s_v3",
"memory": 112.0,
"cpu": 6
},
{
"baseline": 1.0,
"generation": "current",
"price": 6.12,
"burstable": false,
"instanceType": "Standard_NC12s_v3",
"memory": 224.0,
"cpu": 12
},
{
"baseline": 1.0,
"generation": "current",
"price": 13.464,
"burstable": false,
"instanceType": "Standard_NC24rs_v3",
"memory": 448.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 12.24,
"burstable": false,
"instanceType": "Standard_NC24s_v3",
"memory": 448.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.55,
"burstable": false,
"instanceType": "Standard_G1",
"memory": 28.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.1,
"burstable": false,
"instanceType": "Standard_G2",
"memory": 56.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.2,
"burstable": false,
"instanceType": "Standard_G3",
"memory": 112.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.4,
"burstable": false,
"instanceType": "Standard_G4",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 7.82,
"burstable": false,
"instanceType": "Standard_G5",
"memory": 448.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.55,
"burstable": false,
"instanceType": "Standard_GS1",
"memory": 28.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.1,
"burstable": false,
"instanceType": "Standard_GS2",
"memory": 56.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.2,
"burstable": false,
"instanceType": "Standard_GS3",
"memory": 112.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.4,
"burstable": false,
"instanceType": "Standard_GS4",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.4,
"burstable": false,
"instanceType": "Standard_GS4-4",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.4,
"burstable": false,
"instanceType": "Standard_GS4-8",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 7.82,
"burstable": false,
"instanceType": "Standard_GS5",
"memory": 448.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 7.82,
"burstable": false,
"instanceType": "Standard_GS5-8",
"memory": 448.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 7.82,
"burstable": false,
"instanceType": "Standard_GS5-16",
"memory": 448.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.343,
"burstable": false,
"instanceType": "Standard_L4s",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.686,
"burstable": false,
"instanceType": "Standard_L8s",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.373,
"burstable": false,
"instanceType": "Standard_L16s",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.746,
"burstable": false,
"instanceType": "Standard_L32s",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.202,
"burstable": false,
"instanceType": "Standard_NV6",
"memory": 56.0,
"cpu": 6
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.404,
"burstable": false,
"instanceType": "Standard_NV12",
"memory": 112.0,
"cpu": 12
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.807,
"burstable": false,
"instanceType": "Standard_NV24",
"memory": 224.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.067,
"burstable": false,
"instanceType": "Standard_DS1",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.134,
"burstable": false,
"instanceType": "Standard_DS2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.268,
"burstable": false,
"instanceType": "Standard_DS3",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.536,
"burstable": false,
"instanceType": "Standard_DS4",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.173,
"burstable": false,
"instanceType": "Standard_DS11",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.347,
"burstable": false,
"instanceType": "Standard_DS12",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.694,
"burstable": false,
"instanceType": "Standard_DS13",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.387,
"burstable": false,
"instanceType": "Standard_DS14",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.9,
"burstable": false,
"instanceType": "Standard_NC6",
"memory": 56.0,
"cpu": 6
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.8,
"burstable": false,
"instanceType": "Standard_NC12",
"memory": 112.0,
"cpu": 12
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.6,
"burstable": false,
"instanceType": "Standard_NC24",
"memory": 224.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.085,
"burstable": false,
"instanceType": "Standard_F2s_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.169,
"burstable": false,
"instanceType": "Standard_F4s_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.338,
"burstable": false,
"instanceType": "Standard_F8s_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.677,
"burstable": false,
"instanceType": "Standard_F16s_v2",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.353,
"burstable": false,
"instanceType": "Standard_F32s_v2",
"memory": 64.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.706,
"burstable": false,
"instanceType": "Standard_F64s_v2",
"memory": 128.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.045,
"burstable": false,
"instanceType": "Standard_F72s_v2",
"memory": 144.0,
"cpu": 72
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.1716,
"burstable": false,
"instanceType": "Standard_L8s_v2",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.3432,
"burstable": false,
"instanceType": "Standard_L16s_v2",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 6.24,
"burstable": false,
"instanceType": "Standard_L80s_v2",
"memory": 640.0,
"cpu": 80
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.5365,
"burstable": false,
"instanceType": "Standard_M8ms",
"memory": 218.75,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.073,
"burstable": false,
"instanceType": "Standard_M16ms",
"memory": 437.5,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.873,
"burstable": false,
"instanceType": "Standard_M32ls",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 6.146,
"burstable": false,
"instanceType": "Standard_M32ms",
"memory": 875.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.707,
"burstable": false,
"instanceType": "Standard_M32ts",
"memory": 192.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.415,
"burstable": false,
"instanceType": "Standard_M64ls",
"memory": 512.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 10.337,
"burstable": false,
"instanceType": "Standard_M64ms",
"memory": 1750.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 6.669,
"burstable": false,
"instanceType": "Standard_M64s",
"memory": 1000.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 26.688,
"burstable": false,
"instanceType": "Standard_M128ms",
"memory": 3800.0,
"cpu": 128
},
{
"baseline": 1.0,
"generation": "current",
"price": 13.338,
"burstable": false,
"instanceType": "Standard_M128s",
"memory": 2000.0,
"cpu": 128
}
],
"Central India": [
{
"baseline": 1.0,
"generation": "current",
"price": 0.085,
"burstable": false,
"instanceType": "Standard_F2s_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.17,
"burstable": false,
"instanceType": "Standard_F4s_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.34,
"burstable": false,
"instanceType": "Standard_F8s_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.68,
"burstable": false,
"instanceType": "Standard_F16s_v2",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.36,
"burstable": false,
"instanceType": "Standard_F32s_v2",
"memory": 64.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.72,
"burstable": false,
"instanceType": "Standard_F64s_v2",
"memory": 128.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.06,
"burstable": false,
"instanceType": "Standard_F72s_v2",
"memory": 144.0,
"cpu": 72
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.1165,
"burstable": false,
"instanceType": "Standard_M8ms",
"memory": 218.75,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.2331,
"burstable": false,
"instanceType": "Standard_M16ms",
"memory": 437.5,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.27522,
"burstable": false,
"instanceType": "Standard_M32ls",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 8.4661,
"burstable": false,
"instanceType": "Standard_M32ms",
"memory": 875.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.08598,
"burstable": false,
"instanceType": "Standard_M32ts",
"memory": 192.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 6.1731,
"burstable": false,
"instanceType": "Standard_M64ls",
"memory": 512.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 14.24,
"burstable": false,
"instanceType": "Standard_M64ms",
"memory": 1750.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 9.187,
"burstable": false,
"instanceType": "Standard_M64s",
"memory": 1000.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 36.765,
"burstable": false,
"instanceType": "Standard_M128ms",
"memory": 3800.0,
"cpu": 128
},
{
"baseline": 1.0,
"generation": "current",
"price": 18.374,
"burstable": false,
"instanceType": "Standard_M128s",
"memory": 2000.0,
"cpu": 128
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.02,
"burstable": false,
"instanceType": "Standard_A0",
"memory": 0.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.066,
"burstable": false,
"instanceType": "Standard_A1",
"memory": 1.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.096,
"burstable": false,
"instanceType": "Standard_A2",
"memory": 3.5,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.232,
"burstable": false,
"instanceType": "Standard_A3",
"memory": 7.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.26,
"burstable": false,
"instanceType": "Standard_A5",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.524,
"burstable": false,
"instanceType": "Standard_A4",
"memory": 14.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.52,
"burstable": false,
"instanceType": "Standard_A6",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.04,
"burstable": false,
"instanceType": "Standard_A7",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.047,
"burstable": false,
"instanceType": "Standard_A1_v2",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.158,
"burstable": false,
"instanceType": "Standard_A2m_v2",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.098,
"burstable": false,
"instanceType": "Standard_A2_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.333,
"burstable": false,
"instanceType": "Standard_A4m_v2",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.206,
"burstable": false,
"instanceType": "Standard_A4_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.699,
"burstable": false,
"instanceType": "Standard_A8m_v2",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.433,
"burstable": false,
"instanceType": "Standard_A8_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 0.2,
"generation": "current",
"price": 0.0267,
"burstable": true,
"instanceType": "Standard_B1ms",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 0.1,
"generation": "current",
"price": 0.0133,
"burstable": true,
"instanceType": "Standard_B1s",
"memory": 1.0,
"cpu": 1
},
{
"baseline": 0.6,
"generation": "current",
"price": 0.107,
"burstable": true,
"instanceType": "Standard_B2ms",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 0.4,
"generation": "current",
"price": 0.053,
"burstable": true,
"instanceType": "Standard_B2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 0.9,
"generation": "current",
"price": 0.214,
"burstable": true,
"instanceType": "Standard_B4ms",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.35,
"generation": "current",
"price": 0.428,
"burstable": true,
"instanceType": "Standard_B8ms",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.084,
"burstable": false,
"instanceType": "Standard_D1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.169,
"burstable": false,
"instanceType": "Standard_D2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.337,
"burstable": false,
"instanceType": "Standard_D3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.675,
"burstable": false,
"instanceType": "Standard_D4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.35,
"burstable": false,
"instanceType": "Standard_D5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.189,
"burstable": false,
"instanceType": "Standard_D11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.379,
"burstable": false,
"instanceType": "Standard_D12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.758,
"burstable": false,
"instanceType": "Standard_D13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.516,
"burstable": false,
"instanceType": "Standard_D14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.169,
"burstable": false,
"instanceType": "Standard_D2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.337,
"burstable": false,
"instanceType": "Standard_D3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.675,
"burstable": false,
"instanceType": "Standard_D4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.35,
"burstable": false,
"instanceType": "Standard_D5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.189,
"burstable": false,
"instanceType": "Standard_D11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.379,
"burstable": false,
"instanceType": "Standard_D12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.758,
"burstable": false,
"instanceType": "Standard_D13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.516,
"burstable": false,
"instanceType": "Standard_D14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.049,
"burstable": false,
"instanceType": "Standard_F1",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.099,
"burstable": false,
"instanceType": "Standard_F2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.198,
"burstable": false,
"instanceType": "Standard_F4",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.395,
"burstable": false,
"instanceType": "Standard_F8",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.79,
"burstable": false,
"instanceType": "Standard_F16",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.084,
"burstable": false,
"instanceType": "Standard_DS1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.169,
"burstable": false,
"instanceType": "Standard_DS2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.337,
"burstable": false,
"instanceType": "Standard_DS3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.675,
"burstable": false,
"instanceType": "Standard_DS4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.35,
"burstable": false,
"instanceType": "Standard_DS5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.189,
"burstable": false,
"instanceType": "Standard_DS11-1_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.189,
"burstable": false,
"instanceType": "Standard_DS11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.379,
"burstable": false,
"instanceType": "Standard_DS12-1_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.379,
"burstable": false,
"instanceType": "Standard_DS12-2_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.379,
"burstable": false,
"instanceType": "Standard_DS12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.758,
"burstable": false,
"instanceType": "Standard_DS13-2_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.758,
"burstable": false,
"instanceType": "Standard_DS13-4_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.758,
"burstable": false,
"instanceType": "Standard_DS13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.516,
"burstable": false,
"instanceType": "Standard_DS14-4_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.516,
"burstable": false,
"instanceType": "Standard_DS14-8_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.516,
"burstable": false,
"instanceType": "Standard_DS14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.169,
"burstable": false,
"instanceType": "Standard_DS2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.337,
"burstable": false,
"instanceType": "Standard_DS3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.675,
"burstable": false,
"instanceType": "Standard_DS4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.35,
"burstable": false,
"instanceType": "Standard_DS5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.189,
"burstable": false,
"instanceType": "Standard_DS11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.379,
"burstable": false,
"instanceType": "Standard_DS12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.758,
"burstable": false,
"instanceType": "Standard_DS13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.516,
"burstable": false,
"instanceType": "Standard_DS14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.049,
"burstable": false,
"instanceType": "Standard_F1s",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.099,
"burstable": false,
"instanceType": "Standard_F2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.198,
"burstable": false,
"instanceType": "Standard_F4s",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.395,
"burstable": false,
"instanceType": "Standard_F8s",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.79,
"burstable": false,
"instanceType": "Standard_F16s",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.105,
"burstable": false,
"instanceType": "Standard_D2_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.21,
"burstable": false,
"instanceType": "Standard_D4_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.42,
"burstable": false,
"instanceType": "Standard_D8_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.84,
"burstable": false,
"instanceType": "Standard_D16_v3",
"memory": 64.1,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.68,
"burstable": false,
"instanceType": "Standard_D32_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.36,
"burstable": false,
"instanceType": "Standard_D64_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.105,
"burstable": false,
"instanceType": "Standard_D2s_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.21,
"burstable": false,
"instanceType": "Standard_D4s_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.42,
"burstable": false,
"instanceType": "Standard_D8s_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.84,
"burstable": false,
"instanceType": "Standard_D16s_v3",
"memory": 64.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.68,
"burstable": false,
"instanceType": "Standard_D32s_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.36,
"burstable": false,
"instanceType": "Standard_D64s_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.137,
"burstable": false,
"instanceType": "Standard_E2_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.274,
"burstable": false,
"instanceType": "Standard_E4_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.548,
"burstable": false,
"instanceType": "Standard_E8_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.096,
"burstable": false,
"instanceType": "Standard_E16_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.37,
"burstable": false,
"instanceType": "Standard_E20_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.192,
"burstable": false,
"instanceType": "Standard_E32_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.937,
"burstable": false,
"instanceType": "Standard_E64_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.137,
"burstable": false,
"instanceType": "Standard_E2s_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.274,
"burstable": false,
"instanceType": "Standard_E4s_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.548,
"burstable": false,
"instanceType": "Standard_E8s_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.096,
"burstable": false,
"instanceType": "Standard_E16s_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.37,
"burstable": false,
"instanceType": "Standard_E20s_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.192,
"burstable": false,
"instanceType": "Standard_E32s_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.937,
"burstable": false,
"instanceType": "Standard_E64s_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.895,
"burstable": false,
"instanceType": "Standard_D15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.718,
"burstable": false,
"instanceType": "Standard_NV6",
"memory": 56.0,
"cpu": 6
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.436,
"burstable": false,
"instanceType": "Standard_NV12",
"memory": 112.0,
"cpu": 12
},
{
"baseline": 1.0,
"generation": "current",
"price": 6.872,
"burstable": false,
"instanceType": "Standard_NV24",
"memory": 224.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.895,
"burstable": false,
"instanceType": "Standard_DS15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.814,
"burstable": false,
"instanceType": "Standard_NC6s_v3",
"memory": 112.0,
"cpu": 6
},
{
"baseline": 1.0,
"generation": "current",
"price": 11.628,
"burstable": false,
"instanceType": "Standard_NC12s_v3",
"memory": 224.0,
"cpu": 12
},
{
"baseline": 1.0,
"generation": "current",
"price": 25.5816,
"burstable": false,
"instanceType": "Standard_NC24rs_v3",
"memory": 448.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 23.256,
"burstable": false,
"instanceType": "Standard_NC24s_v3",
"memory": 448.0,
"cpu": 24
}
],
"Australia Central": [
{
"baseline": 1.0,
"generation": "current",
"price": 0.03,
"burstable": false,
"instanceType": "Standard_A0",
"memory": 0.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.08875,
"burstable": false,
"instanceType": "Standard_A1",
"memory": 1.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.1225,
"burstable": false,
"instanceType": "Standard_A2",
"memory": 3.5,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.355,
"burstable": false,
"instanceType": "Standard_A3",
"memory": 7.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.3475,
"burstable": false,
"instanceType": "Standard_A5",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.71,
"burstable": false,
"instanceType": "Standard_A4",
"memory": 14.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.695,
"burstable": false,
"instanceType": "Standard_A6",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.39,
"burstable": false,
"instanceType": "Standard_A7",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.105,
"burstable": false,
"instanceType": "Standard_D1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.21,
"burstable": false,
"instanceType": "Standard_D2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.42,
"burstable": false,
"instanceType": "Standard_D3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.841,
"burstable": false,
"instanceType": "Standard_D4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.681,
"burstable": false,
"instanceType": "Standard_D5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.249,
"burstable": false,
"instanceType": "Standard_D11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.49875,
"burstable": false,
"instanceType": "Standard_D12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.997,
"burstable": false,
"instanceType": "Standard_D13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.995,
"burstable": false,
"instanceType": "Standard_D14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.493,
"burstable": false,
"instanceType": "Standard_D15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.21,
"burstable": false,
"instanceType": "Standard_D2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.42,
"burstable": false,
"instanceType": "Standard_D3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.841,
"burstable": false,
"instanceType": "Standard_D4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.681,
"burstable": false,
"instanceType": "Standard_D5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.249,
"burstable": false,
"instanceType": "Standard_D11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.49875,
"burstable": false,
"instanceType": "Standard_D12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.997,
"burstable": false,
"instanceType": "Standard_D13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.995,
"burstable": false,
"instanceType": "Standard_D14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.081,
"burstable": false,
"instanceType": "Standard_F1",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.162,
"burstable": false,
"instanceType": "Standard_F2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.325,
"burstable": false,
"instanceType": "Standard_F4",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.65,
"burstable": false,
"instanceType": "Standard_F8",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.3,
"burstable": false,
"instanceType": "Standard_F16",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.0625,
"burstable": false,
"instanceType": "Standard_A1_v2",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.18625,
"burstable": false,
"instanceType": "Standard_A2m_v2",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.1325,
"burstable": false,
"instanceType": "Standard_A2_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.39,
"burstable": false,
"instanceType": "Standard_A4m_v2",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.2775,
"burstable": false,
"instanceType": "Standard_A4_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.81875,
"burstable": false,
"instanceType": "Standard_A8m_v2",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.58375,
"burstable": false,
"instanceType": "Standard_A8_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.139,
"burstable": false,
"instanceType": "Standard_F2s_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.277,
"burstable": false,
"instanceType": "Standard_F4s_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.554,
"burstable": false,
"instanceType": "Standard_F8s_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.108,
"burstable": false,
"instanceType": "Standard_F16s_v2",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.217,
"burstable": false,
"instanceType": "Standard_F32s_v2",
"memory": 64.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.434,
"burstable": false,
"instanceType": "Standard_F64s_v2",
"memory": 128.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.988,
"burstable": false,
"instanceType": "Standard_F72s_v2",
"memory": 144.0,
"cpu": 72
},
{
"baseline": 0.2,
"generation": "current",
"price": 0.04,
"burstable": true,
"instanceType": "Standard_B1ms",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 0.1,
"generation": "current",
"price": 0.02,
"burstable": true,
"instanceType": "Standard_B1s",
"memory": 1.0,
"cpu": 1
},
{
"baseline": 0.6,
"generation": "current",
"price": 0.16,
"burstable": true,
"instanceType": "Standard_B2ms",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 0.4,
"generation": "current",
"price": 0.08,
"burstable": true,
"instanceType": "Standard_B2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 0.9,
"generation": "current",
"price": 0.32,
"burstable": true,
"instanceType": "Standard_B4ms",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.35,
"generation": "current",
"price": 0.64,
"burstable": true,
"instanceType": "Standard_B8ms",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.105,
"burstable": false,
"instanceType": "Standard_DS1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.21,
"burstable": false,
"instanceType": "Standard_DS2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.42,
"burstable": false,
"instanceType": "Standard_DS3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.841,
"burstable": false,
"instanceType": "Standard_DS4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.681,
"burstable": false,
"instanceType": "Standard_DS5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.249,
"burstable": false,
"instanceType": "Standard_DS11-1_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.249,
"burstable": false,
"instanceType": "Standard_DS11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.49875,
"burstable": false,
"instanceType": "Standard_DS12-1_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.49875,
"burstable": false,
"instanceType": "Standard_DS12-2_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.49875,
"burstable": false,
"instanceType": "Standard_DS12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.997,
"burstable": false,
"instanceType": "Standard_DS13-2_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.997,
"burstable": false,
"instanceType": "Standard_DS13-4_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.997,
"burstable": false,
"instanceType": "Standard_DS13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.995,
"burstable": false,
"instanceType": "Standard_DS14-4_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.995,
"burstable": false,
"instanceType": "Standard_DS14-8_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.995,
"burstable": false,
"instanceType": "Standard_DS14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.21,
"burstable": false,
"instanceType": "Standard_DS2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.42,
"burstable": false,
"instanceType": "Standard_DS3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.841,
"burstable": false,
"instanceType": "Standard_DS4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.681,
"burstable": false,
"instanceType": "Standard_DS5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.249,
"burstable": false,
"instanceType": "Standard_DS11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.49875,
"burstable": false,
"instanceType": "Standard_DS12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.997,
"burstable": false,
"instanceType": "Standard_DS13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.995,
"burstable": false,
"instanceType": "Standard_DS14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.081,
"burstable": false,
"instanceType": "Standard_F1s",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.162,
"burstable": false,
"instanceType": "Standard_F2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.325,
"burstable": false,
"instanceType": "Standard_F4s",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.65,
"burstable": false,
"instanceType": "Standard_F8s",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.3,
"burstable": false,
"instanceType": "Standard_F16s",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.15625,
"burstable": false,
"instanceType": "Standard_D2_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.3125,
"burstable": false,
"instanceType": "Standard_D4_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.625,
"burstable": false,
"instanceType": "Standard_D8_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.25,
"burstable": false,
"instanceType": "Standard_D16_v3",
"memory": 64.1,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.5,
"burstable": false,
"instanceType": "Standard_D32_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.0,
"burstable": false,
"instanceType": "Standard_D64_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.15625,
"burstable": false,
"instanceType": "Standard_D2s_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.3125,
"burstable": false,
"instanceType": "Standard_D4s_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.625,
"burstable": false,
"instanceType": "Standard_D8s_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.25,
"burstable": false,
"instanceType": "Standard_D16s_v3",
"memory": 64.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.5,
"burstable": false,
"instanceType": "Standard_D32s_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.0,
"burstable": false,
"instanceType": "Standard_D64s_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.2,
"burstable": false,
"instanceType": "Standard_E2_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.39875,
"burstable": false,
"instanceType": "Standard_E4_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.7975,
"burstable": false,
"instanceType": "Standard_E8_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.59625,
"burstable": false,
"instanceType": "Standard_E16_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.1925,
"burstable": false,
"instanceType": "Standard_E32_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.434,
"burstable": false,
"instanceType": "Standard_E64_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.2,
"burstable": false,
"instanceType": "Standard_E2s_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.39875,
"burstable": false,
"instanceType": "Standard_E4s_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.7975,
"burstable": false,
"instanceType": "Standard_E8s_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.59625,
"burstable": false,
"instanceType": "Standard_E16s_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.1925,
"burstable": false,
"instanceType": "Standard_E32s_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.434,
"burstable": false,
"instanceType": "Standard_E64s_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.785,
"burstable": false,
"instanceType": "Standard_M8ms",
"memory": 218.75,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.57,
"burstable": false,
"instanceType": "Standard_M16ms",
"memory": 437.5,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.31,
"burstable": false,
"instanceType": "Standard_M32ls",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 11.14,
"burstable": false,
"instanceType": "Standard_M32ms",
"memory": 875.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.061,
"burstable": false,
"instanceType": "Standard_M32ts",
"memory": 192.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 8.123,
"burstable": false,
"instanceType": "Standard_M64ls",
"memory": 512.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 18.737,
"burstable": false,
"instanceType": "Standard_M64ms",
"memory": 1750.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 12.088,
"burstable": false,
"instanceType": "Standard_M64s",
"memory": 1000.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 48.372,
"burstable": false,
"instanceType": "Standard_M128ms",
"memory": 3800.0,
"cpu": 128
},
{
"baseline": 1.0,
"generation": "current",
"price": 24.175,
"burstable": false,
"instanceType": "Standard_M128s",
"memory": 2000.0,
"cpu": 128
}
],
"Central US": [
{
"baseline": 1.0,
"generation": "current",
"price": 0.02,
"burstable": false,
"instanceType": "Standard_A0",
"memory": 0.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.025,
"burstable": false,
"instanceType": "Standard_A1",
"memory": 1.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.12,
"burstable": false,
"instanceType": "Standard_A2",
"memory": 3.5,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.188,
"burstable": false,
"instanceType": "Standard_A3",
"memory": 7.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.25,
"burstable": false,
"instanceType": "Standard_A5",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.376,
"burstable": false,
"instanceType": "Standard_A4",
"memory": 14.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.5,
"burstable": false,
"instanceType": "Standard_A6",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.0,
"burstable": false,
"instanceType": "Standard_A7",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.073,
"burstable": false,
"instanceType": "Standard_D1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.146,
"burstable": false,
"instanceType": "Standard_D2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.293,
"burstable": false,
"instanceType": "Standard_D3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.585,
"burstable": false,
"instanceType": "Standard_D4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.17,
"burstable": false,
"instanceType": "Standard_D5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.185,
"burstable": false,
"instanceType": "Standard_D11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.371,
"burstable": false,
"instanceType": "Standard_D12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.741,
"burstable": false,
"instanceType": "Standard_D13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.482,
"burstable": false,
"instanceType": "Standard_D14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.853,
"burstable": false,
"instanceType": "Standard_D15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.146,
"burstable": false,
"instanceType": "Standard_D2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.293,
"burstable": false,
"instanceType": "Standard_D3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.585,
"burstable": false,
"instanceType": "Standard_D4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.17,
"burstable": false,
"instanceType": "Standard_D5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.185,
"burstable": false,
"instanceType": "Standard_D11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.371,
"burstable": false,
"instanceType": "Standard_D12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.741,
"burstable": false,
"instanceType": "Standard_D13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.482,
"burstable": false,
"instanceType": "Standard_D14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.055,
"burstable": false,
"instanceType": "Standard_F1",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.109,
"burstable": false,
"instanceType": "Standard_F2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.219,
"burstable": false,
"instanceType": "Standard_F4",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.438,
"burstable": false,
"instanceType": "Standard_F8",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.875,
"burstable": false,
"instanceType": "Standard_F16",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.043,
"burstable": false,
"instanceType": "Standard_A1_v2",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.129,
"burstable": false,
"instanceType": "Standard_A2m_v2",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.091,
"burstable": false,
"instanceType": "Standard_A2_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.27,
"burstable": false,
"instanceType": "Standard_A4m_v2",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.191,
"burstable": false,
"instanceType": "Standard_A4_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.568,
"burstable": false,
"instanceType": "Standard_A8m_v2",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.4,
"burstable": false,
"instanceType": "Standard_A8_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.077,
"burstable": false,
"instanceType": "Standard_DS1",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.154,
"burstable": false,
"instanceType": "Standard_DS2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.308,
"burstable": false,
"instanceType": "Standard_DS3",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.616,
"burstable": false,
"instanceType": "Standard_DS4",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.193,
"burstable": false,
"instanceType": "Standard_DS11",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.386,
"burstable": false,
"instanceType": "Standard_DS12",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.771,
"burstable": false,
"instanceType": "Standard_DS13",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.542,
"burstable": false,
"instanceType": "Standard_DS14",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.11,
"burstable": false,
"instanceType": "Standard_D2_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.22,
"burstable": false,
"instanceType": "Standard_D4_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.44,
"burstable": false,
"instanceType": "Standard_D8_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.88,
"burstable": false,
"instanceType": "Standard_D16_v3",
"memory": 64.1,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.76,
"burstable": false,
"instanceType": "Standard_D32_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.077,
"burstable": false,
"instanceType": "Standard_D1",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.154,
"burstable": false,
"instanceType": "Standard_D2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.308,
"burstable": false,
"instanceType": "Standard_D3",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.616,
"burstable": false,
"instanceType": "Standard_D4",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.193,
"burstable": false,
"instanceType": "Standard_D11",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.386,
"burstable": false,
"instanceType": "Standard_D12",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.771,
"burstable": false,
"instanceType": "Standard_D13",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.542,
"burstable": false,
"instanceType": "Standard_D14",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 0.2,
"generation": "current",
"price": 0.025,
"burstable": true,
"instanceType": "Standard_B1ms",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 0.1,
"generation": "current",
"price": 0.013,
"burstable": true,
"instanceType": "Standard_B1s",
"memory": 1.0,
"cpu": 1
},
{
"baseline": 0.6,
"generation": "current",
"price": 0.0998,
"burstable": true,
"instanceType": "Standard_B2ms",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 0.4,
"generation": "current",
"price": 0.0499,
"burstable": true,
"instanceType": "Standard_B2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 0.9,
"generation": "current",
"price": 0.2,
"burstable": true,
"instanceType": "Standard_B4ms",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.35,
"generation": "current",
"price": 0.399,
"burstable": true,
"instanceType": "Standard_B8ms",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.073,
"burstable": false,
"instanceType": "Standard_DS1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.146,
"burstable": false,
"instanceType": "Standard_DS2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.293,
"burstable": false,
"instanceType": "Standard_DS3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.585,
"burstable": false,
"instanceType": "Standard_DS4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.17,
"burstable": false,
"instanceType": "Standard_DS5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.185,
"burstable": false,
"instanceType": "Standard_DS11-1_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.185,
"burstable": false,
"instanceType": "Standard_DS11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.371,
"burstable": false,
"instanceType": "Standard_DS12-1_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.371,
"burstable": false,
"instanceType": "Standard_DS12-2_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.371,
"burstable": false,
"instanceType": "Standard_DS12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.741,
"burstable": false,
"instanceType": "Standard_DS13-2_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.741,
"burstable": false,
"instanceType": "Standard_DS13-4_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.741,
"burstable": false,
"instanceType": "Standard_DS13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.482,
"burstable": false,
"instanceType": "Standard_DS14-4_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.482,
"burstable": false,
"instanceType": "Standard_DS14-8_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.482,
"burstable": false,
"instanceType": "Standard_DS14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.146,
"burstable": false,
"instanceType": "Standard_DS2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.293,
"burstable": false,
"instanceType": "Standard_DS3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.585,
"burstable": false,
"instanceType": "Standard_DS4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.17,
"burstable": false,
"instanceType": "Standard_DS5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.185,
"burstable": false,
"instanceType": "Standard_DS11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.371,
"burstable": false,
"instanceType": "Standard_DS12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.741,
"burstable": false,
"instanceType": "Standard_DS13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.482,
"burstable": false,
"instanceType": "Standard_DS14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.055,
"burstable": false,
"instanceType": "Standard_F1s",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.109,
"burstable": false,
"instanceType": "Standard_F2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.219,
"burstable": false,
"instanceType": "Standard_F4s",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.438,
"burstable": false,
"instanceType": "Standard_F8s",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.875,
"burstable": false,
"instanceType": "Standard_F16s",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.52,
"burstable": false,
"instanceType": "Standard_D64_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.11,
"burstable": false,
"instanceType": "Standard_D2s_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.22,
"burstable": false,
"instanceType": "Standard_D4s_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.44,
"burstable": false,
"instanceType": "Standard_D8s_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.88,
"burstable": false,
"instanceType": "Standard_D16s_v3",
"memory": 64.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.76,
"burstable": false,
"instanceType": "Standard_D32s_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.52,
"burstable": false,
"instanceType": "Standard_D64s_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.146,
"burstable": false,
"instanceType": "Standard_E2_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.293,
"burstable": false,
"instanceType": "Standard_E4_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.585,
"burstable": false,
"instanceType": "Standard_E8_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.17,
"burstable": false,
"instanceType": "Standard_E16_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.46,
"burstable": false,
"instanceType": "Standard_E20_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.341,
"burstable": false,
"instanceType": "Standard_E32_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.199,
"burstable": false,
"instanceType": "Standard_E64i_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.2,
"burstable": false,
"instanceType": "Standard_E64_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.146,
"burstable": false,
"instanceType": "Standard_E2s_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.293,
"burstable": false,
"instanceType": "Standard_E4s_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.585,
"burstable": false,
"instanceType": "Standard_E8s_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.17,
"burstable": false,
"instanceType": "Standard_E16s_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.46,
"burstable": false,
"instanceType": "Standard_E20s_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.341,
"burstable": false,
"instanceType": "Standard_E32s_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.199,
"burstable": false,
"instanceType": "Standard_E64is_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.2,
"burstable": false,
"instanceType": "Standard_E64s_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.853,
"burstable": false,
"instanceType": "Standard_DS15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.102,
"burstable": false,
"instanceType": "Standard_F2s_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.204,
"burstable": false,
"instanceType": "Standard_F4s_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.408,
"burstable": false,
"instanceType": "Standard_F8s_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.816,
"burstable": false,
"instanceType": "Standard_F16s_v2",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.632,
"burstable": false,
"instanceType": "Standard_F32s_v2",
"memory": 64.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.264,
"burstable": false,
"instanceType": "Standard_F64s_v2",
"memory": 128.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.672,
"burstable": false,
"instanceType": "Standard_F72s_v2",
"memory": 144.0,
"cpu": 72
}
],
"West US": [
{
"baseline": 0.2,
"generation": "current",
"price": 0.0248,
"burstable": true,
"instanceType": "Standard_B1ms",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 0.1,
"generation": "current",
"price": 0.0124,
"burstable": true,
"instanceType": "Standard_B1s",
"memory": 1.0,
"cpu": 1
},
{
"baseline": 0.6,
"generation": "current",
"price": 0.0992,
"burstable": true,
"instanceType": "Standard_B2ms",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 0.4,
"generation": "current",
"price": 0.0496,
"burstable": true,
"instanceType": "Standard_B2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 0.9,
"generation": "current",
"price": 0.198,
"burstable": true,
"instanceType": "Standard_B4ms",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.35,
"generation": "current",
"price": 0.397,
"burstable": true,
"instanceType": "Standard_B8ms",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.07,
"burstable": false,
"instanceType": "Standard_DS1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.14,
"burstable": false,
"instanceType": "Standard_DS2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.279,
"burstable": false,
"instanceType": "Standard_DS3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.559,
"burstable": false,
"instanceType": "Standard_DS4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.117,
"burstable": false,
"instanceType": "Standard_DS5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.185,
"burstable": false,
"instanceType": "Standard_DS11-1_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.185,
"burstable": false,
"instanceType": "Standard_DS11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.37,
"burstable": false,
"instanceType": "Standard_DS12-1_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.37,
"burstable": false,
"instanceType": "Standard_DS12-2_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.37,
"burstable": false,
"instanceType": "Standard_DS12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.741,
"burstable": false,
"instanceType": "Standard_DS13-2_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.741,
"burstable": false,
"instanceType": "Standard_DS13-4_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.741,
"burstable": false,
"instanceType": "Standard_DS13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.482,
"burstable": false,
"instanceType": "Standard_DS14-4_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.482,
"burstable": false,
"instanceType": "Standard_DS14-8_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.482,
"burstable": false,
"instanceType": "Standard_DS14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.852,
"burstable": false,
"instanceType": "Standard_DS15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.14,
"burstable": false,
"instanceType": "Standard_DS2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.279,
"burstable": false,
"instanceType": "Standard_DS3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.559,
"burstable": false,
"instanceType": "Standard_DS4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.117,
"burstable": false,
"instanceType": "Standard_DS5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.185,
"burstable": false,
"instanceType": "Standard_DS11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.37,
"burstable": false,
"instanceType": "Standard_DS12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.741,
"burstable": false,
"instanceType": "Standard_DS13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.482,
"burstable": false,
"instanceType": "Standard_DS14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.062,
"burstable": false,
"instanceType": "Standard_F1s",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.124,
"burstable": false,
"instanceType": "Standard_F2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.249,
"burstable": false,
"instanceType": "Standard_F4s",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.498,
"burstable": false,
"instanceType": "Standard_F8s",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.996,
"burstable": false,
"instanceType": "Standard_F16s",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.117,
"burstable": false,
"instanceType": "Standard_D2s_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.234,
"burstable": false,
"instanceType": "Standard_D4s_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.468,
"burstable": false,
"instanceType": "Standard_D8s_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.936,
"burstable": false,
"instanceType": "Standard_D16s_v3",
"memory": 64.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.872,
"burstable": false,
"instanceType": "Standard_D32s_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.02,
"burstable": false,
"instanceType": "Standard_A0",
"memory": 0.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.06,
"burstable": false,
"instanceType": "Standard_A1",
"memory": 1.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.081,
"burstable": false,
"instanceType": "Standard_A2",
"memory": 3.5,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.188,
"burstable": false,
"instanceType": "Standard_A3",
"memory": 7.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.25,
"burstable": false,
"instanceType": "Standard_A5",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.376,
"burstable": false,
"instanceType": "Standard_A4",
"memory": 14.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.5,
"burstable": false,
"instanceType": "Standard_A6",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.0,
"burstable": false,
"instanceType": "Standard_A7",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.07,
"burstable": false,
"instanceType": "Standard_D1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.14,
"burstable": false,
"instanceType": "Standard_D2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.279,
"burstable": false,
"instanceType": "Standard_D3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.559,
"burstable": false,
"instanceType": "Standard_D4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.117,
"burstable": false,
"instanceType": "Standard_D5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.185,
"burstable": false,
"instanceType": "Standard_D11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.37,
"burstable": false,
"instanceType": "Standard_D12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.741,
"burstable": false,
"instanceType": "Standard_D13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.482,
"burstable": false,
"instanceType": "Standard_D14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.852,
"burstable": false,
"instanceType": "Standard_D15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.14,
"burstable": false,
"instanceType": "Standard_D2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.279,
"burstable": false,
"instanceType": "Standard_D3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.559,
"burstable": false,
"instanceType": "Standard_D4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.117,
"burstable": false,
"instanceType": "Standard_D5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.185,
"burstable": false,
"instanceType": "Standard_D11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.37,
"burstable": false,
"instanceType": "Standard_D12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.741,
"burstable": false,
"instanceType": "Standard_D13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.482,
"burstable": false,
"instanceType": "Standard_D14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.062,
"burstable": false,
"instanceType": "Standard_F1",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.124,
"burstable": false,
"instanceType": "Standard_F2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.249,
"burstable": false,
"instanceType": "Standard_F4",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.498,
"burstable": false,
"instanceType": "Standard_F8",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.996,
"burstable": false,
"instanceType": "Standard_F16",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.043,
"burstable": false,
"instanceType": "Standard_A1_v2",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.149,
"burstable": false,
"instanceType": "Standard_A2m_v2",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.091,
"burstable": false,
"instanceType": "Standard_A2_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.297,
"burstable": false,
"instanceType": "Standard_A4m_v2",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.191,
"burstable": false,
"instanceType": "Standard_A4_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.594,
"burstable": false,
"instanceType": "Standard_A8m_v2",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.4,
"burstable": false,
"instanceType": "Standard_A8_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.117,
"burstable": false,
"instanceType": "Standard_D2_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.234,
"burstable": false,
"instanceType": "Standard_D4_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.468,
"burstable": false,
"instanceType": "Standard_D8_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.936,
"burstable": false,
"instanceType": "Standard_D16_v3",
"memory": 64.1,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.872,
"burstable": false,
"instanceType": "Standard_D32_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.077,
"burstable": false,
"instanceType": "Standard_D1",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.154,
"burstable": false,
"instanceType": "Standard_D2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.308,
"burstable": false,
"instanceType": "Standard_D3",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.616,
"burstable": false,
"instanceType": "Standard_D4",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.193,
"burstable": false,
"instanceType": "Standard_D11",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.386,
"burstable": false,
"instanceType": "Standard_D12",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.771,
"burstable": false,
"instanceType": "Standard_D13",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.542,
"burstable": false,
"instanceType": "Standard_D14",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.077,
"burstable": false,
"instanceType": "Standard_DS1",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.154,
"burstable": false,
"instanceType": "Standard_DS2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.308,
"burstable": false,
"instanceType": "Standard_DS3",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.616,
"burstable": false,
"instanceType": "Standard_DS4",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.193,
"burstable": false,
"instanceType": "Standard_DS11",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.386,
"burstable": false,
"instanceType": "Standard_DS12",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.771,
"burstable": false,
"instanceType": "Standard_DS13",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.542,
"burstable": false,
"instanceType": "Standard_DS14",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.744,
"burstable": false,
"instanceType": "Standard_D64_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.744,
"burstable": false,
"instanceType": "Standard_D64s_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.148,
"burstable": false,
"instanceType": "Standard_E2_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.296,
"burstable": false,
"instanceType": "Standard_E4_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.593,
"burstable": false,
"instanceType": "Standard_E8_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.186,
"burstable": false,
"instanceType": "Standard_E16_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.48,
"burstable": false,
"instanceType": "Standard_E20_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.371,
"burstable": false,
"instanceType": "Standard_E32_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.032,
"burstable": false,
"instanceType": "Standard_E64i_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.032,
"burstable": false,
"instanceType": "Standard_E64_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.148,
"burstable": false,
"instanceType": "Standard_E2s_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.296,
"burstable": false,
"instanceType": "Standard_E4s_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.593,
"burstable": false,
"instanceType": "Standard_E8s_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.186,
"burstable": false,
"instanceType": "Standard_E16s_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.48,
"burstable": false,
"instanceType": "Standard_E20s_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.371,
"burstable": false,
"instanceType": "Standard_E32s_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.032,
"burstable": false,
"instanceType": "Standard_E64is_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.032,
"burstable": false,
"instanceType": "Standard_E64s_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.61,
"burstable": false,
"instanceType": "Standard_G1",
"memory": 28.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.22,
"burstable": false,
"instanceType": "Standard_G2",
"memory": 56.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.44,
"burstable": false,
"instanceType": "Standard_G3",
"memory": 112.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.88,
"burstable": false,
"instanceType": "Standard_G4",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 8.69,
"burstable": false,
"instanceType": "Standard_G5",
"memory": 448.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.61,
"burstable": false,
"instanceType": "Standard_GS1",
"memory": 28.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.22,
"burstable": false,
"instanceType": "Standard_GS2",
"memory": 56.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.44,
"burstable": false,
"instanceType": "Standard_GS3",
"memory": 112.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.88,
"burstable": false,
"instanceType": "Standard_GS4",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.88,
"burstable": false,
"instanceType": "Standard_GS4-4",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.88,
"burstable": false,
"instanceType": "Standard_GS4-8",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 8.69,
"burstable": false,
"instanceType": "Standard_GS5",
"memory": 448.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 8.69,
"burstable": false,
"instanceType": "Standard_GS5-8",
"memory": 448.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 8.69,
"burstable": false,
"instanceType": "Standard_GS5-16",
"memory": 448.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.344,
"burstable": false,
"instanceType": "Standard_L4s",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.688,
"burstable": false,
"instanceType": "Standard_L8s",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.376,
"burstable": false,
"instanceType": "Standard_L16s",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.752,
"burstable": false,
"instanceType": "Standard_L32s",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.975,
"burstable": false,
"instanceType": "Standard_A8",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.95,
"burstable": false,
"instanceType": "Standard_A9",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.78,
"burstable": false,
"instanceType": "Standard_A10",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.56,
"burstable": false,
"instanceType": "Standard_A11",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.971,
"burstable": false,
"instanceType": "Standard_H8",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.941,
"burstable": false,
"instanceType": "Standard_H16",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.301,
"burstable": false,
"instanceType": "Standard_H8m",
"memory": 112.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.601,
"burstable": false,
"instanceType": "Standard_H16m",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.136,
"burstable": false,
"instanceType": "Standard_H16r",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.861,
"burstable": false,
"instanceType": "Standard_H16mr",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.767,
"burstable": false,
"instanceType": "Standard_NV6s_v2",
"memory": 112.0,
"cpu": 6
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.534,
"burstable": false,
"instanceType": "Standard_NV12s_v2",
"memory": 224.0,
"cpu": 12
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.069,
"burstable": false,
"instanceType": "Standard_NV24s_v2",
"memory": 448.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.106,
"burstable": false,
"instanceType": "Standard_F2s_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.212,
"burstable": false,
"instanceType": "Standard_F4s_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.424,
"burstable": false,
"instanceType": "Standard_F8s_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.848,
"burstable": false,
"instanceType": "Standard_F16s_v2",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.696,
"burstable": false,
"instanceType": "Standard_F32s_v2",
"memory": 64.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.392,
"burstable": false,
"instanceType": "Standard_F64s_v2",
"memory": 128.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.816,
"burstable": false,
"instanceType": "Standard_F72s_v2",
"memory": 144.0,
"cpu": 72
}
],
"UK West": [
{
"baseline": 0.2,
"generation": "current",
"price": 0.0235,
"burstable": true,
"instanceType": "Standard_B1ms",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 0.1,
"generation": "current",
"price": 0.013,
"burstable": true,
"instanceType": "Standard_B1s",
"memory": 1.0,
"cpu": 1
},
{
"baseline": 0.6,
"generation": "current",
"price": 0.094,
"burstable": true,
"instanceType": "Standard_B2ms",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 0.4,
"generation": "current",
"price": 0.047,
"burstable": true,
"instanceType": "Standard_B2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 0.9,
"generation": "current",
"price": 0.188,
"burstable": true,
"instanceType": "Standard_B4ms",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.35,
"generation": "current",
"price": 0.376,
"burstable": true,
"instanceType": "Standard_B8ms",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.088,
"burstable": false,
"instanceType": "Standard_D1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.175,
"burstable": false,
"instanceType": "Standard_D2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.351,
"burstable": false,
"instanceType": "Standard_D3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.702,
"burstable": false,
"instanceType": "Standard_D4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.404,
"burstable": false,
"instanceType": "Standard_D5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.234,
"burstable": false,
"instanceType": "Standard_D11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.469,
"burstable": false,
"instanceType": "Standard_D12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.937,
"burstable": false,
"instanceType": "Standard_D13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.874,
"burstable": false,
"instanceType": "Standard_D14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.175,
"burstable": false,
"instanceType": "Standard_D2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.351,
"burstable": false,
"instanceType": "Standard_D3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.702,
"burstable": false,
"instanceType": "Standard_D4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.404,
"burstable": false,
"instanceType": "Standard_D5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.234,
"burstable": false,
"instanceType": "Standard_D11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.469,
"burstable": false,
"instanceType": "Standard_D12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.937,
"burstable": false,
"instanceType": "Standard_D13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.874,
"burstable": false,
"instanceType": "Standard_D14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.059,
"burstable": false,
"instanceType": "Standard_F1",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.119,
"burstable": false,
"instanceType": "Standard_F2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.237,
"burstable": false,
"instanceType": "Standard_F4",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.475,
"burstable": false,
"instanceType": "Standard_F8",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.95,
"burstable": false,
"instanceType": "Standard_F16",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.088,
"burstable": false,
"instanceType": "Standard_DS1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.175,
"burstable": false,
"instanceType": "Standard_DS2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.351,
"burstable": false,
"instanceType": "Standard_DS3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.702,
"burstable": false,
"instanceType": "Standard_DS4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.404,
"burstable": false,
"instanceType": "Standard_DS5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.234,
"burstable": false,
"instanceType": "Standard_DS11-1_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.234,
"burstable": false,
"instanceType": "Standard_DS11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.469,
"burstable": false,
"instanceType": "Standard_DS12-1_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.469,
"burstable": false,
"instanceType": "Standard_DS12-2_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.469,
"burstable": false,
"instanceType": "Standard_DS12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.937,
"burstable": false,
"instanceType": "Standard_DS13-2_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.937,
"burstable": false,
"instanceType": "Standard_DS13-4_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.937,
"burstable": false,
"instanceType": "Standard_DS13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.874,
"burstable": false,
"instanceType": "Standard_DS14-4_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.874,
"burstable": false,
"instanceType": "Standard_DS14-8_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.874,
"burstable": false,
"instanceType": "Standard_DS14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.175,
"burstable": false,
"instanceType": "Standard_DS2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.351,
"burstable": false,
"instanceType": "Standard_DS3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.702,
"burstable": false,
"instanceType": "Standard_DS4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.404,
"burstable": false,
"instanceType": "Standard_DS5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.234,
"burstable": false,
"instanceType": "Standard_DS11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.469,
"burstable": false,
"instanceType": "Standard_DS12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.937,
"burstable": false,
"instanceType": "Standard_DS13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.874,
"burstable": false,
"instanceType": "Standard_DS14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.059,
"burstable": false,
"instanceType": "Standard_F1s",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.119,
"burstable": false,
"instanceType": "Standard_F2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.237,
"burstable": false,
"instanceType": "Standard_F4s",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.475,
"burstable": false,
"instanceType": "Standard_F8s",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.95,
"burstable": false,
"instanceType": "Standard_F16s",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.05,
"burstable": false,
"instanceType": "Standard_A1_v2",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.158,
"burstable": false,
"instanceType": "Standard_A2m_v2",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.106,
"burstable": false,
"instanceType": "Standard_A2_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.333,
"burstable": false,
"instanceType": "Standard_A4m_v2",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.222,
"burstable": false,
"instanceType": "Standard_A4_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.699,
"burstable": false,
"instanceType": "Standard_A8m_v2",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.467,
"burstable": false,
"instanceType": "Standard_A8_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.116,
"burstable": false,
"instanceType": "Standard_D2_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.232,
"burstable": false,
"instanceType": "Standard_D4_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.464,
"burstable": false,
"instanceType": "Standard_D8_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.928,
"burstable": false,
"instanceType": "Standard_D16_v3",
"memory": 64.1,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.856,
"burstable": false,
"instanceType": "Standard_D32_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.712,
"burstable": false,
"instanceType": "Standard_D64_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.116,
"burstable": false,
"instanceType": "Standard_D2s_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.232,
"burstable": false,
"instanceType": "Standard_D4s_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.464,
"burstable": false,
"instanceType": "Standard_D8s_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.928,
"burstable": false,
"instanceType": "Standard_D16s_v3",
"memory": 64.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.856,
"burstable": false,
"instanceType": "Standard_D32s_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.712,
"burstable": false,
"instanceType": "Standard_D64s_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.156,
"burstable": false,
"instanceType": "Standard_E2_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.312,
"burstable": false,
"instanceType": "Standard_E4_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.624,
"burstable": false,
"instanceType": "Standard_E8_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.248,
"burstable": false,
"instanceType": "Standard_E16_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.56,
"burstable": false,
"instanceType": "Standard_E20_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.496,
"burstable": false,
"instanceType": "Standard_E32_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.264,
"burstable": false,
"instanceType": "Standard_E64i_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.264,
"burstable": false,
"instanceType": "Standard_E64_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.156,
"burstable": false,
"instanceType": "Standard_E2s_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.312,
"burstable": false,
"instanceType": "Standard_E4s_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.624,
"burstable": false,
"instanceType": "Standard_E8s_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.248,
"burstable": false,
"instanceType": "Standard_E16s_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.56,
"burstable": false,
"instanceType": "Standard_E20s_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.496,
"burstable": false,
"instanceType": "Standard_E32s_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.264,
"burstable": false,
"instanceType": "Standard_E64is_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.264,
"burstable": false,
"instanceType": "Standard_E64s_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.022,
"burstable": false,
"instanceType": "Standard_A0",
"memory": 0.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.066,
"burstable": false,
"instanceType": "Standard_A1",
"memory": 1.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.101,
"burstable": false,
"instanceType": "Standard_A2",
"memory": 3.5,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.264,
"burstable": false,
"instanceType": "Standard_A3",
"memory": 7.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.297,
"burstable": false,
"instanceType": "Standard_A5",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.528,
"burstable": false,
"instanceType": "Standard_A4",
"memory": 14.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.594,
"burstable": false,
"instanceType": "Standard_A6",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.188,
"burstable": false,
"instanceType": "Standard_A7",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.343,
"burstable": false,
"instanceType": "Standard_D15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.343,
"burstable": false,
"instanceType": "Standard_DS15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.101,
"burstable": false,
"instanceType": "Standard_F2s_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.202,
"burstable": false,
"instanceType": "Standard_F4s_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.405,
"burstable": false,
"instanceType": "Standard_F8s_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.809,
"burstable": false,
"instanceType": "Standard_F16s_v2",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.618,
"burstable": false,
"instanceType": "Standard_F32s_v2",
"memory": 64.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.237,
"burstable": false,
"instanceType": "Standard_F64s_v2",
"memory": 128.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.641,
"burstable": false,
"instanceType": "Standard_F72s_v2",
"memory": 144.0,
"cpu": 72
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.936,
"burstable": false,
"instanceType": "Standard_M8ms",
"memory": 218.75,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.872,
"burstable": false,
"instanceType": "Standard_M16ms",
"memory": 437.5,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.36141,
"burstable": false,
"instanceType": "Standard_M32ls",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 7.744,
"burstable": false,
"instanceType": "Standard_M32ms",
"memory": 875.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.16719,
"burstable": false,
"instanceType": "Standard_M32ts",
"memory": 192.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 6.33555,
"burstable": false,
"instanceType": "Standard_M64ls",
"memory": 512.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 13.024,
"burstable": false,
"instanceType": "Standard_M64ms",
"memory": 1750.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 8.403,
"burstable": false,
"instanceType": "Standard_M64s",
"memory": 1000.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 33.6269,
"burstable": false,
"instanceType": "Standard_M128ms",
"memory": 3800.0,
"cpu": 128
},
{
"baseline": 1.0,
"generation": "current",
"price": 16.806,
"burstable": false,
"instanceType": "Standard_M128s",
"memory": 2000.0,
"cpu": 128
}
],
"UK South": [
{
"baseline": 0.2,
"generation": "current",
"price": 0.0236,
"burstable": true,
"instanceType": "Standard_B1ms",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 0.1,
"generation": "current",
"price": 0.0118,
"burstable": true,
"instanceType": "Standard_B1s",
"memory": 1.0,
"cpu": 1
},
{
"baseline": 0.6,
"generation": "current",
"price": 0.0944,
"burstable": true,
"instanceType": "Standard_B2ms",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 0.4,
"generation": "current",
"price": 0.0472,
"burstable": true,
"instanceType": "Standard_B2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 0.9,
"generation": "current",
"price": 0.189,
"burstable": true,
"instanceType": "Standard_B4ms",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.35,
"generation": "current",
"price": 0.378,
"burstable": true,
"instanceType": "Standard_B8ms",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.02,
"burstable": false,
"instanceType": "Standard_A0",
"memory": 0.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.026,
"burstable": false,
"instanceType": "Standard_A1",
"memory": 1.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.132,
"burstable": false,
"instanceType": "Standard_A2",
"memory": 3.5,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.224,
"burstable": false,
"instanceType": "Standard_A3",
"memory": 7.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.297,
"burstable": false,
"instanceType": "Standard_A5",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.528,
"burstable": false,
"instanceType": "Standard_A4",
"memory": 14.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.594,
"burstable": false,
"instanceType": "Standard_A6",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.188,
"burstable": false,
"instanceType": "Standard_A7",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.088,
"burstable": false,
"instanceType": "Standard_D1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.176,
"burstable": false,
"instanceType": "Standard_D2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.351,
"burstable": false,
"instanceType": "Standard_D3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.702,
"burstable": false,
"instanceType": "Standard_D4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.405,
"burstable": false,
"instanceType": "Standard_D5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.234,
"burstable": false,
"instanceType": "Standard_D11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.469,
"burstable": false,
"instanceType": "Standard_D12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.937,
"burstable": false,
"instanceType": "Standard_D13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.874,
"burstable": false,
"instanceType": "Standard_D14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.343,
"burstable": false,
"instanceType": "Standard_D15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.176,
"burstable": false,
"instanceType": "Standard_D2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.351,
"burstable": false,
"instanceType": "Standard_D3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.702,
"burstable": false,
"instanceType": "Standard_D4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.405,
"burstable": false,
"instanceType": "Standard_D5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.234,
"burstable": false,
"instanceType": "Standard_D11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.469,
"burstable": false,
"instanceType": "Standard_D12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.937,
"burstable": false,
"instanceType": "Standard_D13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.874,
"burstable": false,
"instanceType": "Standard_D14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.059,
"burstable": false,
"instanceType": "Standard_F1",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.119,
"burstable": false,
"instanceType": "Standard_F2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.237,
"burstable": false,
"instanceType": "Standard_F4",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.475,
"burstable": false,
"instanceType": "Standard_F8",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.95,
"burstable": false,
"instanceType": "Standard_F16",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.088,
"burstable": false,
"instanceType": "Standard_DS1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.176,
"burstable": false,
"instanceType": "Standard_DS2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.351,
"burstable": false,
"instanceType": "Standard_DS3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.702,
"burstable": false,
"instanceType": "Standard_DS4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.405,
"burstable": false,
"instanceType": "Standard_DS5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.234,
"burstable": false,
"instanceType": "Standard_DS11-1_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.234,
"burstable": false,
"instanceType": "Standard_DS11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.469,
"burstable": false,
"instanceType": "Standard_DS12-1_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.469,
"burstable": false,
"instanceType": "Standard_DS12-2_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.469,
"burstable": false,
"instanceType": "Standard_DS12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.937,
"burstable": false,
"instanceType": "Standard_DS13-2_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.937,
"burstable": false,
"instanceType": "Standard_DS13-4_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.937,
"burstable": false,
"instanceType": "Standard_DS13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.874,
"burstable": false,
"instanceType": "Standard_DS14-4_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.874,
"burstable": false,
"instanceType": "Standard_DS14-8_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.874,
"burstable": false,
"instanceType": "Standard_DS14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.343,
"burstable": false,
"instanceType": "Standard_DS15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.176,
"burstable": false,
"instanceType": "Standard_DS2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.351,
"burstable": false,
"instanceType": "Standard_DS3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.702,
"burstable": false,
"instanceType": "Standard_DS4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.405,
"burstable": false,
"instanceType": "Standard_DS5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.234,
"burstable": false,
"instanceType": "Standard_DS11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.469,
"burstable": false,
"instanceType": "Standard_DS12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.937,
"burstable": false,
"instanceType": "Standard_DS13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.874,
"burstable": false,
"instanceType": "Standard_DS14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.059,
"burstable": false,
"instanceType": "Standard_F1s",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.119,
"burstable": false,
"instanceType": "Standard_F2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.237,
"burstable": false,
"instanceType": "Standard_F4s",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.475,
"burstable": false,
"instanceType": "Standard_F8s",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.95,
"burstable": false,
"instanceType": "Standard_F16s",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.05,
"burstable": false,
"instanceType": "Standard_A1_v2",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.178,
"burstable": false,
"instanceType": "Standard_A2m_v2",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.106,
"burstable": false,
"instanceType": "Standard_A2_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.374,
"burstable": false,
"instanceType": "Standard_A4m_v2",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.222,
"burstable": false,
"instanceType": "Standard_A4_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.786,
"burstable": false,
"instanceType": "Standard_A8m_v2",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.467,
"burstable": false,
"instanceType": "Standard_A8_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.116,
"burstable": false,
"instanceType": "Standard_D2_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.232,
"burstable": false,
"instanceType": "Standard_D4_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.464,
"burstable": false,
"instanceType": "Standard_D8_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.928,
"burstable": false,
"instanceType": "Standard_D16_v3",
"memory": 64.1,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.856,
"burstable": false,
"instanceType": "Standard_D32_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.116,
"burstable": false,
"instanceType": "Standard_D2s_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.232,
"burstable": false,
"instanceType": "Standard_D4s_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.464,
"burstable": false,
"instanceType": "Standard_D8s_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.928,
"burstable": false,
"instanceType": "Standard_D16s_v3",
"memory": 64.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.856,
"burstable": false,
"instanceType": "Standard_D32s_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.507,
"burstable": false,
"instanceType": "Standard_NV6",
"memory": 56.0,
"cpu": 6
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.003,
"burstable": false,
"instanceType": "Standard_NV12",
"memory": 112.0,
"cpu": 12
},
{
"baseline": 1.0,
"generation": "current",
"price": 6.006,
"burstable": false,
"instanceType": "Standard_NV24",
"memory": 224.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.712,
"burstable": false,
"instanceType": "Standard_D64_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.712,
"burstable": false,
"instanceType": "Standard_D64s_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.156,
"burstable": false,
"instanceType": "Standard_E2_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.312,
"burstable": false,
"instanceType": "Standard_E4_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.624,
"burstable": false,
"instanceType": "Standard_E8_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.248,
"burstable": false,
"instanceType": "Standard_E16_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.56,
"burstable": false,
"instanceType": "Standard_E20_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.496,
"burstable": false,
"instanceType": "Standard_E32_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.264,
"burstable": false,
"instanceType": "Standard_E64i_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.264,
"burstable": false,
"instanceType": "Standard_E64_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.156,
"burstable": false,
"instanceType": "Standard_E2s_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.312,
"burstable": false,
"instanceType": "Standard_E4s_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.624,
"burstable": false,
"instanceType": "Standard_E8s_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.248,
"burstable": false,
"instanceType": "Standard_E16s_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.56,
"burstable": false,
"instanceType": "Standard_E20s_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.496,
"burstable": false,
"instanceType": "Standard_E32s_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.264,
"burstable": false,
"instanceType": "Standard_E64is_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.264,
"burstable": false,
"instanceType": "Standard_E64s_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.283,
"burstable": false,
"instanceType": "Standard_NC6",
"memory": 56.0,
"cpu": 6
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.566,
"burstable": false,
"instanceType": "Standard_NC12",
"memory": 112.0,
"cpu": 12
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.133,
"burstable": false,
"instanceType": "Standard_NC24",
"memory": 224.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.36141,
"burstable": false,
"instanceType": "Standard_M32ls",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 7.744,
"burstable": false,
"instanceType": "Standard_M32ms",
"memory": 875.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.16719,
"burstable": false,
"instanceType": "Standard_M32ts",
"memory": 192.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 6.33555,
"burstable": false,
"instanceType": "Standard_M64ls",
"memory": 512.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 13.024,
"burstable": false,
"instanceType": "Standard_M64ms",
"memory": 1750.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 8.403,
"burstable": false,
"instanceType": "Standard_M64s",
"memory": 1000.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 33.6269,
"burstable": false,
"instanceType": "Standard_M128ms",
"memory": 3800.0,
"cpu": 128
},
{
"baseline": 1.0,
"generation": "current",
"price": 16.806,
"burstable": false,
"instanceType": "Standard_M128s",
"memory": 2000.0,
"cpu": 128
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.952,
"burstable": false,
"instanceType": "Standard_H8",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.902,
"burstable": false,
"instanceType": "Standard_H16",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.274,
"burstable": false,
"instanceType": "Standard_H8m",
"memory": 112.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.549,
"burstable": false,
"instanceType": "Standard_H16m",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.092,
"burstable": false,
"instanceType": "Standard_H16r",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.803,
"burstable": false,
"instanceType": "Standard_H16mr",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.101,
"burstable": false,
"instanceType": "Standard_F2s_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.202,
"burstable": false,
"instanceType": "Standard_F4s_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.404,
"burstable": false,
"instanceType": "Standard_F8s_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.808,
"burstable": false,
"instanceType": "Standard_F16s_v2",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.616,
"burstable": false,
"instanceType": "Standard_F32s_v2",
"memory": 64.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.232,
"burstable": false,
"instanceType": "Standard_F64s_v2",
"memory": 128.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.636,
"burstable": false,
"instanceType": "Standard_F72s_v2",
"memory": 144.0,
"cpu": 72
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.936,
"burstable": false,
"instanceType": "Standard_M8ms",
"memory": 218.75,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.872,
"burstable": false,
"instanceType": "Standard_M16ms",
"memory": 437.5,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.825,
"burstable": false,
"instanceType": "Standard_NC6s_v3",
"memory": 112.0,
"cpu": 6
},
{
"baseline": 1.0,
"generation": "current",
"price": 7.65,
"burstable": false,
"instanceType": "Standard_NC12s_v3",
"memory": 224.0,
"cpu": 12
},
{
"baseline": 1.0,
"generation": "current",
"price": 16.83,
"burstable": false,
"instanceType": "Standard_NC24rs_v3",
"memory": 448.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 15.3,
"burstable": false,
"instanceType": "Standard_NC24s_v3",
"memory": 448.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.439,
"burstable": false,
"instanceType": "Standard_G1",
"memory": 28.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.878,
"burstable": false,
"instanceType": "Standard_G2",
"memory": 56.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.757,
"burstable": false,
"instanceType": "Standard_G3",
"memory": 112.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.514,
"burstable": false,
"instanceType": "Standard_G4",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 7.027,
"burstable": false,
"instanceType": "Standard_G5",
"memory": 448.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.439,
"burstable": false,
"instanceType": "Standard_GS1",
"memory": 28.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.878,
"burstable": false,
"instanceType": "Standard_GS2",
"memory": 56.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.757,
"burstable": false,
"instanceType": "Standard_GS3",
"memory": 112.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.514,
"burstable": false,
"instanceType": "Standard_GS4",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.514,
"burstable": false,
"instanceType": "Standard_GS4-4",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.514,
"burstable": false,
"instanceType": "Standard_GS4-8",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 7.027,
"burstable": false,
"instanceType": "Standard_GS5",
"memory": 448.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 7.027,
"burstable": false,
"instanceType": "Standard_GS5-8",
"memory": 448.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 7.027,
"burstable": false,
"instanceType": "Standard_GS5-16",
"memory": 448.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.362,
"burstable": false,
"instanceType": "Standard_L4s",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.724,
"burstable": false,
"instanceType": "Standard_L8s",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.448,
"burstable": false,
"instanceType": "Standard_L16s",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.896,
"burstable": false,
"instanceType": "Standard_L32s",
"memory": 256.0,
"cpu": 32
}
],
"Brazil South": [
{
"baseline": 1.0,
"generation": "current",
"price": 0.024,
"burstable": false,
"instanceType": "Standard_A0",
"memory": 0.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.041,
"burstable": false,
"instanceType": "Standard_A1",
"memory": 1.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.16,
"burstable": false,
"instanceType": "Standard_A2",
"memory": 3.5,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.32,
"burstable": false,
"instanceType": "Standard_A3",
"memory": 7.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.291,
"burstable": false,
"instanceType": "Standard_A5",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.464,
"burstable": false,
"instanceType": "Standard_A4",
"memory": 14.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.582,
"burstable": false,
"instanceType": "Standard_A6",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.164,
"burstable": false,
"instanceType": "Standard_A7",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.095,
"burstable": false,
"instanceType": "Standard_D1",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.19,
"burstable": false,
"instanceType": "Standard_D2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.38,
"burstable": false,
"instanceType": "Standard_D3",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.76,
"burstable": false,
"instanceType": "Standard_D4",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.235,
"burstable": false,
"instanceType": "Standard_D11",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.47,
"burstable": false,
"instanceType": "Standard_D12",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.939,
"burstable": false,
"instanceType": "Standard_D13",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.879,
"burstable": false,
"instanceType": "Standard_D14",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.086,
"burstable": false,
"instanceType": "Standard_D1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.171,
"burstable": false,
"instanceType": "Standard_D2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.343,
"burstable": false,
"instanceType": "Standard_D3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.685,
"burstable": false,
"instanceType": "Standard_D4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.37,
"burstable": false,
"instanceType": "Standard_D5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.235,
"burstable": false,
"instanceType": "Standard_D11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.47,
"burstable": false,
"instanceType": "Standard_D12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.94,
"burstable": false,
"instanceType": "Standard_D13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.879,
"burstable": false,
"instanceType": "Standard_D14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.349,
"burstable": false,
"instanceType": "Standard_D15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.171,
"burstable": false,
"instanceType": "Standard_D2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.343,
"burstable": false,
"instanceType": "Standard_D3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.685,
"burstable": false,
"instanceType": "Standard_D4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.37,
"burstable": false,
"instanceType": "Standard_D5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.235,
"burstable": false,
"instanceType": "Standard_D11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.47,
"burstable": false,
"instanceType": "Standard_D12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.94,
"burstable": false,
"instanceType": "Standard_D13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.879,
"burstable": false,
"instanceType": "Standard_D14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.072,
"burstable": false,
"instanceType": "Standard_F1",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.144,
"burstable": false,
"instanceType": "Standard_F2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.287,
"burstable": false,
"instanceType": "Standard_F4",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.574,
"burstable": false,
"instanceType": "Standard_F8",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.148,
"burstable": false,
"instanceType": "Standard_F16",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.061,
"burstable": false,
"instanceType": "Standard_A1_v2",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.208,
"burstable": false,
"instanceType": "Standard_A2m_v2",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.129,
"burstable": false,
"instanceType": "Standard_A2_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.437,
"burstable": false,
"instanceType": "Standard_A4m_v2",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.27,
"burstable": false,
"instanceType": "Standard_A4_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.917,
"burstable": false,
"instanceType": "Standard_A8m_v2",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.567,
"burstable": false,
"instanceType": "Standard_A8_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.159,
"burstable": false,
"instanceType": "Standard_D2_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.318,
"burstable": false,
"instanceType": "Standard_D4_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.636,
"burstable": false,
"instanceType": "Standard_D8_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.272,
"burstable": false,
"instanceType": "Standard_D16_v3",
"memory": 64.1,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.544,
"burstable": false,
"instanceType": "Standard_D32_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 0.2,
"generation": "current",
"price": 0.0336,
"burstable": true,
"instanceType": "Standard_B1ms",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 0.1,
"generation": "current",
"price": 0.0168,
"burstable": true,
"instanceType": "Standard_B1s",
"memory": 1.0,
"cpu": 1
},
{
"baseline": 0.6,
"generation": "current",
"price": 0.134,
"burstable": true,
"instanceType": "Standard_B2ms",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 0.4,
"generation": "current",
"price": 0.0672,
"burstable": true,
"instanceType": "Standard_B2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 0.9,
"generation": "current",
"price": 0.269,
"burstable": true,
"instanceType": "Standard_B4ms",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.35,
"generation": "current",
"price": 0.538,
"burstable": true,
"instanceType": "Standard_B8ms",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.086,
"burstable": false,
"instanceType": "Standard_DS1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.171,
"burstable": false,
"instanceType": "Standard_DS2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.343,
"burstable": false,
"instanceType": "Standard_DS3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.685,
"burstable": false,
"instanceType": "Standard_DS4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.37,
"burstable": false,
"instanceType": "Standard_DS5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.235,
"burstable": false,
"instanceType": "Standard_DS11-1_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.235,
"burstable": false,
"instanceType": "Standard_DS11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.47,
"burstable": false,
"instanceType": "Standard_DS12-1_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.47,
"burstable": false,
"instanceType": "Standard_DS12-2_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.47,
"burstable": false,
"instanceType": "Standard_DS12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.94,
"burstable": false,
"instanceType": "Standard_DS13-2_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.94,
"burstable": false,
"instanceType": "Standard_DS13-4_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.94,
"burstable": false,
"instanceType": "Standard_DS13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.879,
"burstable": false,
"instanceType": "Standard_DS14-4_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.879,
"burstable": false,
"instanceType": "Standard_DS14-8_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.879,
"burstable": false,
"instanceType": "Standard_DS14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.171,
"burstable": false,
"instanceType": "Standard_DS2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.343,
"burstable": false,
"instanceType": "Standard_DS3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.685,
"burstable": false,
"instanceType": "Standard_DS4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.37,
"burstable": false,
"instanceType": "Standard_DS5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.235,
"burstable": false,
"instanceType": "Standard_DS11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.47,
"burstable": false,
"instanceType": "Standard_DS12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.94,
"burstable": false,
"instanceType": "Standard_DS13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.879,
"burstable": false,
"instanceType": "Standard_DS14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.072,
"burstable": false,
"instanceType": "Standard_F1s",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.144,
"burstable": false,
"instanceType": "Standard_F2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.287,
"burstable": false,
"instanceType": "Standard_F4s",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.574,
"burstable": false,
"instanceType": "Standard_F8s",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.148,
"burstable": false,
"instanceType": "Standard_F16s",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.088,
"burstable": false,
"instanceType": "Standard_D64_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.159,
"burstable": false,
"instanceType": "Standard_D2s_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.318,
"burstable": false,
"instanceType": "Standard_D4s_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.636,
"burstable": false,
"instanceType": "Standard_D8s_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.272,
"burstable": false,
"instanceType": "Standard_D16s_v3",
"memory": 64.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.544,
"burstable": false,
"instanceType": "Standard_D32s_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.088,
"burstable": false,
"instanceType": "Standard_D64s_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.235,
"burstable": false,
"instanceType": "Standard_E2_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.47,
"burstable": false,
"instanceType": "Standard_E4_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.94,
"burstable": false,
"instanceType": "Standard_E8_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.879,
"burstable": false,
"instanceType": "Standard_E16_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.8,
"burstable": false,
"instanceType": "Standard_E20_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.758,
"burstable": false,
"instanceType": "Standard_E32_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 6.764,
"burstable": false,
"instanceType": "Standard_E64i_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 6.764,
"burstable": false,
"instanceType": "Standard_E64_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.235,
"burstable": false,
"instanceType": "Standard_E2s_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.47,
"burstable": false,
"instanceType": "Standard_E4s_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.94,
"burstable": false,
"instanceType": "Standard_E8s_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.879,
"burstable": false,
"instanceType": "Standard_E16s_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.8,
"burstable": false,
"instanceType": "Standard_E20s_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.758,
"burstable": false,
"instanceType": "Standard_E32s_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 6.764,
"burstable": false,
"instanceType": "Standard_E64is_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 6.764,
"burstable": false,
"instanceType": "Standard_E64s_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.349,
"burstable": false,
"instanceType": "Standard_DS15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.131,
"burstable": false,
"instanceType": "Standard_F2s_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.262,
"burstable": false,
"instanceType": "Standard_F4s_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.524,
"burstable": false,
"instanceType": "Standard_F8s_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.048,
"burstable": false,
"instanceType": "Standard_F16s_v2",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.096,
"burstable": false,
"instanceType": "Standard_F32s_v2",
"memory": 64.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.192,
"burstable": false,
"instanceType": "Standard_F64s_v2",
"memory": 128.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.716,
"burstable": false,
"instanceType": "Standard_F72s_v2",
"memory": 144.0,
"cpu": 72
}
],
"Korea Central": [
{
"baseline": 0.2,
"generation": "current",
"price": 0.0281,
"burstable": true,
"instanceType": "Standard_B1ms",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 0.1,
"generation": "current",
"price": 0.014,
"burstable": true,
"instanceType": "Standard_B1s",
"memory": 1.0,
"cpu": 1
},
{
"baseline": 0.6,
"generation": "current",
"price": 0.112,
"burstable": true,
"instanceType": "Standard_B2ms",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 0.4,
"generation": "current",
"price": 0.0562,
"burstable": true,
"instanceType": "Standard_B2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 0.9,
"generation": "current",
"price": 0.225,
"burstable": true,
"instanceType": "Standard_B4ms",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.35,
"generation": "current",
"price": 0.449,
"burstable": true,
"instanceType": "Standard_B8ms",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.083,
"burstable": false,
"instanceType": "Standard_D1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.165,
"burstable": false,
"instanceType": "Standard_D2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.33,
"burstable": false,
"instanceType": "Standard_D3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.66,
"burstable": false,
"instanceType": "Standard_D4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.321,
"burstable": false,
"instanceType": "Standard_D5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.2,
"burstable": false,
"instanceType": "Standard_D11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.399,
"burstable": false,
"instanceType": "Standard_D12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.798,
"burstable": false,
"instanceType": "Standard_D13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.596,
"burstable": false,
"instanceType": "Standard_D14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.165,
"burstable": false,
"instanceType": "Standard_D2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.33,
"burstable": false,
"instanceType": "Standard_D3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.66,
"burstable": false,
"instanceType": "Standard_D4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.321,
"burstable": false,
"instanceType": "Standard_D5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.2,
"burstable": false,
"instanceType": "Standard_D11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.399,
"burstable": false,
"instanceType": "Standard_D12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.798,
"burstable": false,
"instanceType": "Standard_D13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.596,
"burstable": false,
"instanceType": "Standard_D14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.051,
"burstable": false,
"instanceType": "Standard_F1",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.102,
"burstable": false,
"instanceType": "Standard_F2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.204,
"burstable": false,
"instanceType": "Standard_F4",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.408,
"burstable": false,
"instanceType": "Standard_F8",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.816,
"burstable": false,
"instanceType": "Standard_F16",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.083,
"burstable": false,
"instanceType": "Standard_DS1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.165,
"burstable": false,
"instanceType": "Standard_DS2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.33,
"burstable": false,
"instanceType": "Standard_DS3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.66,
"burstable": false,
"instanceType": "Standard_DS4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.321,
"burstable": false,
"instanceType": "Standard_DS5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.2,
"burstable": false,
"instanceType": "Standard_DS11-1_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.2,
"burstable": false,
"instanceType": "Standard_DS11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.399,
"burstable": false,
"instanceType": "Standard_DS12-1_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.399,
"burstable": false,
"instanceType": "Standard_DS12-2_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.399,
"burstable": false,
"instanceType": "Standard_DS12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.798,
"burstable": false,
"instanceType": "Standard_DS13-2_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.798,
"burstable": false,
"instanceType": "Standard_DS13-4_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.798,
"burstable": false,
"instanceType": "Standard_DS13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.596,
"burstable": false,
"instanceType": "Standard_DS14-4_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.596,
"burstable": false,
"instanceType": "Standard_DS14-8_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.596,
"burstable": false,
"instanceType": "Standard_DS14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.165,
"burstable": false,
"instanceType": "Standard_DS2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.33,
"burstable": false,
"instanceType": "Standard_DS3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.66,
"burstable": false,
"instanceType": "Standard_DS4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.321,
"burstable": false,
"instanceType": "Standard_DS5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.2,
"burstable": false,
"instanceType": "Standard_DS11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.399,
"burstable": false,
"instanceType": "Standard_DS12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.798,
"burstable": false,
"instanceType": "Standard_DS13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.596,
"burstable": false,
"instanceType": "Standard_DS14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.051,
"burstable": false,
"instanceType": "Standard_F1s",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.102,
"burstable": false,
"instanceType": "Standard_F2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.204,
"burstable": false,
"instanceType": "Standard_F4s",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.408,
"burstable": false,
"instanceType": "Standard_F8s",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.816,
"burstable": false,
"instanceType": "Standard_F16s",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.049,
"burstable": false,
"instanceType": "Standard_A1_v2",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.133,
"burstable": false,
"instanceType": "Standard_A2m_v2",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.102,
"burstable": false,
"instanceType": "Standard_A2_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.278,
"burstable": false,
"instanceType": "Standard_A4m_v2",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.214,
"burstable": false,
"instanceType": "Standard_A4_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.585,
"burstable": false,
"instanceType": "Standard_A8m_v2",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.45,
"burstable": false,
"instanceType": "Standard_A8_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.123,
"burstable": false,
"instanceType": "Standard_D2_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.246,
"burstable": false,
"instanceType": "Standard_D4_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.492,
"burstable": false,
"instanceType": "Standard_D8_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.984,
"burstable": false,
"instanceType": "Standard_D16_v3",
"memory": 64.1,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.968,
"burstable": false,
"instanceType": "Standard_D32_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.936,
"burstable": false,
"instanceType": "Standard_D64_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.123,
"burstable": false,
"instanceType": "Standard_D2s_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.246,
"burstable": false,
"instanceType": "Standard_D4s_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.492,
"burstable": false,
"instanceType": "Standard_D8s_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.984,
"burstable": false,
"instanceType": "Standard_D16s_v3",
"memory": 64.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.968,
"burstable": false,
"instanceType": "Standard_D32s_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.936,
"burstable": false,
"instanceType": "Standard_D64s_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.16,
"burstable": false,
"instanceType": "Standard_E2_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.32,
"burstable": false,
"instanceType": "Standard_E4_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.64,
"burstable": false,
"instanceType": "Standard_E8_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.28,
"burstable": false,
"instanceType": "Standard_E16_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.6,
"burstable": false,
"instanceType": "Standard_E20_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.56,
"burstable": false,
"instanceType": "Standard_E32_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.376,
"burstable": false,
"instanceType": "Standard_E64i_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.376,
"burstable": false,
"instanceType": "Standard_E64_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.16,
"burstable": false,
"instanceType": "Standard_E2s_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.32,
"burstable": false,
"instanceType": "Standard_E4s_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.64,
"burstable": false,
"instanceType": "Standard_E8s_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.28,
"burstable": false,
"instanceType": "Standard_E16s_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.6,
"burstable": false,
"instanceType": "Standard_E20s_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.56,
"burstable": false,
"instanceType": "Standard_E32s_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.376,
"burstable": false,
"instanceType": "Standard_E64is_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.376,
"burstable": false,
"instanceType": "Standard_E64s_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.018,
"burstable": false,
"instanceType": "Standard_A0",
"memory": 0.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.066,
"burstable": false,
"instanceType": "Standard_A1",
"memory": 1.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.108,
"burstable": false,
"instanceType": "Standard_A2",
"memory": 3.5,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.224,
"burstable": false,
"instanceType": "Standard_A3",
"memory": 7.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.172,
"burstable": false,
"instanceType": "Standard_A5",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.528,
"burstable": false,
"instanceType": "Standard_A4",
"memory": 14.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.343,
"burstable": false,
"instanceType": "Standard_A6",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.687,
"burstable": false,
"instanceType": "Standard_A7",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.995,
"burstable": false,
"instanceType": "Standard_D15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.995,
"burstable": false,
"instanceType": "Standard_DS15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.096,
"burstable": false,
"instanceType": "Standard_F2s_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.192,
"burstable": false,
"instanceType": "Standard_F4s_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.384,
"burstable": false,
"instanceType": "Standard_F8s_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.768,
"burstable": false,
"instanceType": "Standard_F16s_v2",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.536,
"burstable": false,
"instanceType": "Standard_F32s_v2",
"memory": 64.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.072,
"burstable": false,
"instanceType": "Standard_F64s_v2",
"memory": 128.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.456,
"burstable": false,
"instanceType": "Standard_F72s_v2",
"memory": 144.0,
"cpu": 72
}
],
"Korea South": [
{
"baseline": 0.2,
"generation": "current",
"price": 0.026,
"burstable": true,
"instanceType": "Standard_B1ms",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 0.1,
"generation": "current",
"price": 0.013,
"burstable": true,
"instanceType": "Standard_B1s",
"memory": 1.0,
"cpu": 1
},
{
"baseline": 0.6,
"generation": "current",
"price": 0.104,
"burstable": true,
"instanceType": "Standard_B2ms",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 0.4,
"generation": "current",
"price": 0.052,
"burstable": true,
"instanceType": "Standard_B2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 0.9,
"generation": "current",
"price": 0.207,
"burstable": true,
"instanceType": "Standard_B4ms",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.35,
"generation": "current",
"price": 0.415,
"burstable": true,
"instanceType": "Standard_B8ms",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.074,
"burstable": false,
"instanceType": "Standard_DS1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.149,
"burstable": false,
"instanceType": "Standard_DS2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.297,
"burstable": false,
"instanceType": "Standard_DS3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.594,
"burstable": false,
"instanceType": "Standard_DS4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.189,
"burstable": false,
"instanceType": "Standard_DS5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.179,
"burstable": false,
"instanceType": "Standard_DS11-1_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.179,
"burstable": false,
"instanceType": "Standard_DS11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.359,
"burstable": false,
"instanceType": "Standard_DS12-1_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.359,
"burstable": false,
"instanceType": "Standard_DS12-2_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.359,
"burstable": false,
"instanceType": "Standard_DS12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.718,
"burstable": false,
"instanceType": "Standard_DS13-2_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.718,
"burstable": false,
"instanceType": "Standard_DS13-4_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.718,
"burstable": false,
"instanceType": "Standard_DS13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.435,
"burstable": false,
"instanceType": "Standard_DS14-4_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.435,
"burstable": false,
"instanceType": "Standard_DS14-8_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.435,
"burstable": false,
"instanceType": "Standard_DS14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.794,
"burstable": false,
"instanceType": "Standard_DS15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.149,
"burstable": false,
"instanceType": "Standard_DS2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.297,
"burstable": false,
"instanceType": "Standard_DS3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.594,
"burstable": false,
"instanceType": "Standard_DS4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.189,
"burstable": false,
"instanceType": "Standard_DS5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.179,
"burstable": false,
"instanceType": "Standard_DS11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.359,
"burstable": false,
"instanceType": "Standard_DS12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.718,
"burstable": false,
"instanceType": "Standard_DS13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.435,
"burstable": false,
"instanceType": "Standard_DS14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.051,
"burstable": false,
"instanceType": "Standard_F1s",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.102,
"burstable": false,
"instanceType": "Standard_F2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.204,
"burstable": false,
"instanceType": "Standard_F4s",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.408,
"burstable": false,
"instanceType": "Standard_F8s",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.816,
"burstable": false,
"instanceType": "Standard_F16s",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.111,
"burstable": false,
"instanceType": "Standard_D2s_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.221,
"burstable": false,
"instanceType": "Standard_D4s_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.443,
"burstable": false,
"instanceType": "Standard_D8s_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.886,
"burstable": false,
"instanceType": "Standard_D16s_v3",
"memory": 64.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.772,
"burstable": false,
"instanceType": "Standard_D32s_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.074,
"burstable": false,
"instanceType": "Standard_D1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.149,
"burstable": false,
"instanceType": "Standard_D2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.297,
"burstable": false,
"instanceType": "Standard_D3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.594,
"burstable": false,
"instanceType": "Standard_D4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.189,
"burstable": false,
"instanceType": "Standard_D5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.179,
"burstable": false,
"instanceType": "Standard_D11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.359,
"burstable": false,
"instanceType": "Standard_D12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.718,
"burstable": false,
"instanceType": "Standard_D13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.435,
"burstable": false,
"instanceType": "Standard_D14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.149,
"burstable": false,
"instanceType": "Standard_D2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.297,
"burstable": false,
"instanceType": "Standard_D3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.594,
"burstable": false,
"instanceType": "Standard_D4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.189,
"burstable": false,
"instanceType": "Standard_D5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.179,
"burstable": false,
"instanceType": "Standard_D11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.359,
"burstable": false,
"instanceType": "Standard_D12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.718,
"burstable": false,
"instanceType": "Standard_D13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.435,
"burstable": false,
"instanceType": "Standard_D14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.051,
"burstable": false,
"instanceType": "Standard_F1",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.102,
"burstable": false,
"instanceType": "Standard_F2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.204,
"burstable": false,
"instanceType": "Standard_F4",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.408,
"burstable": false,
"instanceType": "Standard_F8",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.816,
"burstable": false,
"instanceType": "Standard_F16",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.044,
"burstable": false,
"instanceType": "Standard_A1_v2",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.119,
"burstable": false,
"instanceType": "Standard_A2m_v2",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.092,
"burstable": false,
"instanceType": "Standard_A2_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.251,
"burstable": false,
"instanceType": "Standard_A4m_v2",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.193,
"burstable": false,
"instanceType": "Standard_A4_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.526,
"burstable": false,
"instanceType": "Standard_A8m_v2",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.405,
"burstable": false,
"instanceType": "Standard_A8_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.111,
"burstable": false,
"instanceType": "Standard_D2_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.221,
"burstable": false,
"instanceType": "Standard_D4_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.443,
"burstable": false,
"instanceType": "Standard_D8_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.886,
"burstable": false,
"instanceType": "Standard_D16_v3",
"memory": 64.1,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.772,
"burstable": false,
"instanceType": "Standard_D32_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.544,
"burstable": false,
"instanceType": "Standard_D64_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.544,
"burstable": false,
"instanceType": "Standard_D64s_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.144,
"burstable": false,
"instanceType": "Standard_E2_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.288,
"burstable": false,
"instanceType": "Standard_E4_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.576,
"burstable": false,
"instanceType": "Standard_E8_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.152,
"burstable": false,
"instanceType": "Standard_E16_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.304,
"burstable": false,
"instanceType": "Standard_E32_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.778,
"burstable": false,
"instanceType": "Standard_E64i_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.881,
"burstable": false,
"instanceType": "Standard_E64_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.144,
"burstable": false,
"instanceType": "Standard_E2s_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.288,
"burstable": false,
"instanceType": "Standard_E4s_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.576,
"burstable": false,
"instanceType": "Standard_E8s_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.152,
"burstable": false,
"instanceType": "Standard_E16s_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.304,
"burstable": false,
"instanceType": "Standard_E32s_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.778,
"burstable": false,
"instanceType": "Standard_E64is_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.881,
"burstable": false,
"instanceType": "Standard_E64s_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.018,
"burstable": false,
"instanceType": "Standard_A0",
"memory": 0.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.029,
"burstable": false,
"instanceType": "Standard_A1",
"memory": 1.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.119,
"burstable": false,
"instanceType": "Standard_A2",
"memory": 3.5,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.238,
"burstable": false,
"instanceType": "Standard_A3",
"memory": 7.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.155,
"burstable": false,
"instanceType": "Standard_A5",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.404,
"burstable": false,
"instanceType": "Standard_A4",
"memory": 14.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.309,
"burstable": false,
"instanceType": "Standard_A6",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.618,
"burstable": false,
"instanceType": "Standard_A7",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.794,
"burstable": false,
"instanceType": "Standard_D15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.44,
"burstable": false,
"instanceType": "Standard_E20_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.44,
"burstable": false,
"instanceType": "Standard_E20s_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.0961,
"burstable": false,
"instanceType": "Standard_F2s_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.192,
"burstable": false,
"instanceType": "Standard_F4s_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.384,
"burstable": false,
"instanceType": "Standard_F8s_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.768,
"burstable": false,
"instanceType": "Standard_F16s_v2",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.537,
"burstable": false,
"instanceType": "Standard_F32s_v2",
"memory": 64.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.074,
"burstable": false,
"instanceType": "Standard_F64s_v2",
"memory": 128.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.458,
"burstable": false,
"instanceType": "Standard_F72s_v2",
"memory": 144.0,
"cpu": 72
}
],
"South Central US": [
{
"baseline": 1.0,
"generation": "current",
"price": 0.02,
"burstable": false,
"instanceType": "Standard_A0",
"memory": 0.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.06,
"burstable": false,
"instanceType": "Standard_A1",
"memory": 1.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.12,
"burstable": false,
"instanceType": "Standard_A2",
"memory": 3.5,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.176,
"burstable": false,
"instanceType": "Standard_A3",
"memory": 7.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.22,
"burstable": false,
"instanceType": "Standard_A5",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.352,
"burstable": false,
"instanceType": "Standard_A4",
"memory": 14.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.44,
"burstable": false,
"instanceType": "Standard_A6",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.88,
"burstable": false,
"instanceType": "Standard_A7",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.064,
"burstable": false,
"instanceType": "Standard_D1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.127,
"burstable": false,
"instanceType": "Standard_D2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.254,
"burstable": false,
"instanceType": "Standard_D3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.509,
"burstable": false,
"instanceType": "Standard_D4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.017,
"burstable": false,
"instanceType": "Standard_D5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.166,
"burstable": false,
"instanceType": "Standard_D11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.332,
"burstable": false,
"instanceType": "Standard_D12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.665,
"burstable": false,
"instanceType": "Standard_D13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.33,
"burstable": false,
"instanceType": "Standard_D14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.662,
"burstable": false,
"instanceType": "Standard_D15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.127,
"burstable": false,
"instanceType": "Standard_D2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.254,
"burstable": false,
"instanceType": "Standard_D3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.509,
"burstable": false,
"instanceType": "Standard_D4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.017,
"burstable": false,
"instanceType": "Standard_D5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.166,
"burstable": false,
"instanceType": "Standard_D11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.332,
"burstable": false,
"instanceType": "Standard_D12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.665,
"burstable": false,
"instanceType": "Standard_D13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.33,
"burstable": false,
"instanceType": "Standard_D14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.055,
"burstable": false,
"instanceType": "Standard_F1",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.109,
"burstable": false,
"instanceType": "Standard_F2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.219,
"burstable": false,
"instanceType": "Standard_F4",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.438,
"burstable": false,
"instanceType": "Standard_F8",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.875,
"burstable": false,
"instanceType": "Standard_F16",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.043,
"burstable": false,
"instanceType": "Standard_A1_v2",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.124,
"burstable": false,
"instanceType": "Standard_A2m_v2",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.091,
"burstable": false,
"instanceType": "Standard_A2_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.248,
"burstable": false,
"instanceType": "Standard_A4m_v2",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.191,
"burstable": false,
"instanceType": "Standard_A4_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.495,
"burstable": false,
"instanceType": "Standard_A8m_v2",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.4,
"burstable": false,
"instanceType": "Standard_A8_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 0.2,
"generation": "current",
"price": 0.025,
"burstable": true,
"instanceType": "Standard_B1ms",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 0.1,
"generation": "current",
"price": 0.013,
"burstable": true,
"instanceType": "Standard_B1s",
"memory": 1.0,
"cpu": 1
},
{
"baseline": 0.6,
"generation": "current",
"price": 0.0998,
"burstable": true,
"instanceType": "Standard_B2ms",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 0.4,
"generation": "current",
"price": 0.0499,
"burstable": true,
"instanceType": "Standard_B2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 0.9,
"generation": "current",
"price": 0.2,
"burstable": true,
"instanceType": "Standard_B4ms",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.35,
"generation": "current",
"price": 0.399,
"burstable": true,
"instanceType": "Standard_B8ms",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.064,
"burstable": false,
"instanceType": "Standard_DS1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.127,
"burstable": false,
"instanceType": "Standard_DS2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.254,
"burstable": false,
"instanceType": "Standard_DS3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.509,
"burstable": false,
"instanceType": "Standard_DS4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.017,
"burstable": false,
"instanceType": "Standard_DS5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.166,
"burstable": false,
"instanceType": "Standard_DS11-1_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.166,
"burstable": false,
"instanceType": "Standard_DS11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.332,
"burstable": false,
"instanceType": "Standard_DS12-1_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.332,
"burstable": false,
"instanceType": "Standard_DS12-2_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.332,
"burstable": false,
"instanceType": "Standard_DS12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.665,
"burstable": false,
"instanceType": "Standard_DS13-2_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.665,
"burstable": false,
"instanceType": "Standard_DS13-4_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.665,
"burstable": false,
"instanceType": "Standard_DS13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.33,
"burstable": false,
"instanceType": "Standard_DS14-4_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.33,
"burstable": false,
"instanceType": "Standard_DS14-8_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.33,
"burstable": false,
"instanceType": "Standard_DS14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.662,
"burstable": false,
"instanceType": "Standard_DS15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.127,
"burstable": false,
"instanceType": "Standard_DS2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.254,
"burstable": false,
"instanceType": "Standard_DS3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.509,
"burstable": false,
"instanceType": "Standard_DS4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.017,
"burstable": false,
"instanceType": "Standard_DS5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.166,
"burstable": false,
"instanceType": "Standard_DS11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.332,
"burstable": false,
"instanceType": "Standard_DS12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.665,
"burstable": false,
"instanceType": "Standard_DS13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.33,
"burstable": false,
"instanceType": "Standard_DS14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.055,
"burstable": false,
"instanceType": "Standard_F1s",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.109,
"burstable": false,
"instanceType": "Standard_F2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.219,
"burstable": false,
"instanceType": "Standard_F4s",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.438,
"burstable": false,
"instanceType": "Standard_F8s",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.875,
"burstable": false,
"instanceType": "Standard_F16s",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.11,
"burstable": false,
"instanceType": "Standard_D2s_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.22,
"burstable": false,
"instanceType": "Standard_D4s_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.44,
"burstable": false,
"instanceType": "Standard_D8s_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.88,
"burstable": false,
"instanceType": "Standard_D16s_v3",
"memory": 64.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.76,
"burstable": false,
"instanceType": "Standard_D32s_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.067,
"burstable": false,
"instanceType": "Standard_D1",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.134,
"burstable": false,
"instanceType": "Standard_D2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.268,
"burstable": false,
"instanceType": "Standard_D3",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.536,
"burstable": false,
"instanceType": "Standard_D4",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.173,
"burstable": false,
"instanceType": "Standard_D11",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.347,
"burstable": false,
"instanceType": "Standard_D12",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.694,
"burstable": false,
"instanceType": "Standard_D13",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.387,
"burstable": false,
"instanceType": "Standard_D14",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.11,
"burstable": false,
"instanceType": "Standard_D2_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.22,
"burstable": false,
"instanceType": "Standard_D4_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.44,
"burstable": false,
"instanceType": "Standard_D8_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.88,
"burstable": false,
"instanceType": "Standard_D16_v3",
"memory": 64.1,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.76,
"burstable": false,
"instanceType": "Standard_D32_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.15,
"burstable": false,
"instanceType": "Standard_NV6",
"memory": 56.0,
"cpu": 6
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.3,
"burstable": false,
"instanceType": "Standard_NV12",
"memory": 112.0,
"cpu": 12
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.6,
"burstable": false,
"instanceType": "Standard_NV24",
"memory": 224.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.067,
"burstable": false,
"instanceType": "Standard_DS1",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.134,
"burstable": false,
"instanceType": "Standard_DS2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.268,
"burstable": false,
"instanceType": "Standard_DS3",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.536,
"burstable": false,
"instanceType": "Standard_DS4",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.173,
"burstable": false,
"instanceType": "Standard_DS11",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.347,
"burstable": false,
"instanceType": "Standard_DS12",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.694,
"burstable": false,
"instanceType": "Standard_DS13",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.387,
"burstable": false,
"instanceType": "Standard_DS14",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.254,
"burstable": false,
"instanceType": "Standard_HB60rs",
"memory": 223.52,
"cpu": 60
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.102,
"burstable": false,
"instanceType": "Standard_F2s_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.204,
"burstable": false,
"instanceType": "Standard_F4s_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.408,
"burstable": false,
"instanceType": "Standard_F8s_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.816,
"burstable": false,
"instanceType": "Standard_F16s_v2",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.632,
"burstable": false,
"instanceType": "Standard_F32s_v2",
"memory": 64.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.264,
"burstable": false,
"instanceType": "Standard_F64s_v2",
"memory": 128.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.672,
"burstable": false,
"instanceType": "Standard_F72s_v2",
"memory": 144.0,
"cpu": 72
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.366,
"burstable": false,
"instanceType": "Standard_NC6s_v3",
"memory": 112.0,
"cpu": 6
},
{
"baseline": 1.0,
"generation": "current",
"price": 6.732,
"burstable": false,
"instanceType": "Standard_NC12s_v3",
"memory": 224.0,
"cpu": 12
},
{
"baseline": 1.0,
"generation": "current",
"price": 14.8104,
"burstable": false,
"instanceType": "Standard_NC24rs_v3",
"memory": 448.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 13.464,
"burstable": false,
"instanceType": "Standard_NC24s_v3",
"memory": 448.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.08,
"burstable": false,
"instanceType": "Standard_NC6",
"memory": 56.0,
"cpu": 6
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.16,
"burstable": false,
"instanceType": "Standard_NC12",
"memory": 112.0,
"cpu": 12
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.32,
"burstable": false,
"instanceType": "Standard_NC24",
"memory": 224.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.52,
"burstable": false,
"instanceType": "Standard_D64_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.52,
"burstable": false,
"instanceType": "Standard_D64s_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.146,
"burstable": false,
"instanceType": "Standard_E2_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.293,
"burstable": false,
"instanceType": "Standard_E4_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.585,
"burstable": false,
"instanceType": "Standard_E8_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.17,
"burstable": false,
"instanceType": "Standard_E16_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.46,
"burstable": false,
"instanceType": "Standard_E20_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.341,
"burstable": false,
"instanceType": "Standard_E32_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.199,
"burstable": false,
"instanceType": "Standard_E64i_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.199,
"burstable": false,
"instanceType": "Standard_E64_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.146,
"burstable": false,
"instanceType": "Standard_E2s_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.293,
"burstable": false,
"instanceType": "Standard_E4s_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.585,
"burstable": false,
"instanceType": "Standard_E8s_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.17,
"burstable": false,
"instanceType": "Standard_E16s_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.46,
"burstable": false,
"instanceType": "Standard_E20s_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.341,
"burstable": false,
"instanceType": "Standard_E32s_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.199,
"burstable": false,
"instanceType": "Standard_E64is_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.199,
"burstable": false,
"instanceType": "Standard_E64s_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.875,
"burstable": false,
"instanceType": "Standard_H8",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.749,
"burstable": false,
"instanceType": "Standard_H16",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.172,
"burstable": false,
"instanceType": "Standard_H8m",
"memory": 112.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.343,
"burstable": false,
"instanceType": "Standard_H16m",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.924,
"burstable": false,
"instanceType": "Standard_H16r",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.577,
"burstable": false,
"instanceType": "Standard_H16mr",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.875,
"burstable": false,
"instanceType": "Standard_A8",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.75,
"burstable": false,
"instanceType": "Standard_A9",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.7,
"burstable": false,
"instanceType": "Standard_A10",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.4,
"burstable": false,
"instanceType": "Standard_A11",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.484,
"burstable": false,
"instanceType": "Standard_NC6s_v2",
"memory": 112.0,
"cpu": 6
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.968,
"burstable": false,
"instanceType": "Standard_NC12s_v2",
"memory": 224.0,
"cpu": 12
},
{
"baseline": 1.0,
"generation": "current",
"price": 10.93,
"burstable": false,
"instanceType": "Standard_NC24rs_v2",
"memory": 448.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 9.936,
"burstable": false,
"instanceType": "Standard_NC24s_v2",
"memory": 448.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.684,
"burstable": false,
"instanceType": "Standard_NV6s_v2",
"memory": 112.0,
"cpu": 6
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.368,
"burstable": false,
"instanceType": "Standard_NV12s_v2",
"memory": 224.0,
"cpu": 12
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.736,
"burstable": false,
"instanceType": "Standard_NV24s_v2",
"memory": 448.0,
"cpu": 24
}
],
"East US": [
{
"baseline": 0.2,
"generation": "current",
"price": 0.0207,
"burstable": true,
"instanceType": "Standard_B1ms",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 0.1,
"generation": "current",
"price": 0.0104,
"burstable": true,
"instanceType": "Standard_B1s",
"memory": 1.0,
"cpu": 1
},
{
"baseline": 0.6,
"generation": "current",
"price": 0.0832,
"burstable": true,
"instanceType": "Standard_B2ms",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 0.4,
"generation": "current",
"price": 0.0416,
"burstable": true,
"instanceType": "Standard_B2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 0.9,
"generation": "current",
"price": 0.166,
"burstable": true,
"instanceType": "Standard_B4ms",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.35,
"generation": "current",
"price": 0.333,
"burstable": true,
"instanceType": "Standard_B8ms",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.073,
"burstable": false,
"instanceType": "Standard_DS1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.146,
"burstable": false,
"instanceType": "Standard_DS2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.293,
"burstable": false,
"instanceType": "Standard_DS3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.585,
"burstable": false,
"instanceType": "Standard_DS4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.17,
"burstable": false,
"instanceType": "Standard_DS5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.185,
"burstable": false,
"instanceType": "Standard_DS11-1_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.185,
"burstable": false,
"instanceType": "Standard_DS11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.371,
"burstable": false,
"instanceType": "Standard_DS12-1_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.371,
"burstable": false,
"instanceType": "Standard_DS12-2_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.371,
"burstable": false,
"instanceType": "Standard_DS12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.741,
"burstable": false,
"instanceType": "Standard_DS13-2_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.741,
"burstable": false,
"instanceType": "Standard_DS13-4_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.741,
"burstable": false,
"instanceType": "Standard_DS13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.482,
"burstable": false,
"instanceType": "Standard_DS14-4_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.482,
"burstable": false,
"instanceType": "Standard_DS14-8_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.482,
"burstable": false,
"instanceType": "Standard_DS14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.853,
"burstable": false,
"instanceType": "Standard_DS15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.146,
"burstable": false,
"instanceType": "Standard_DS2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.293,
"burstable": false,
"instanceType": "Standard_DS3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.585,
"burstable": false,
"instanceType": "Standard_DS4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.17,
"burstable": false,
"instanceType": "Standard_DS5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.185,
"burstable": false,
"instanceType": "Standard_DS11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.371,
"burstable": false,
"instanceType": "Standard_DS12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.741,
"burstable": false,
"instanceType": "Standard_DS13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.482,
"burstable": false,
"instanceType": "Standard_DS14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.05,
"burstable": false,
"instanceType": "Standard_F1s",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.099,
"burstable": false,
"instanceType": "Standard_F2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.199,
"burstable": false,
"instanceType": "Standard_F4s",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.398,
"burstable": false,
"instanceType": "Standard_F8s",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.796,
"burstable": false,
"instanceType": "Standard_F16s",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.096,
"burstable": false,
"instanceType": "Standard_D2s_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.192,
"burstable": false,
"instanceType": "Standard_D4s_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.384,
"burstable": false,
"instanceType": "Standard_D8s_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.768,
"burstable": false,
"instanceType": "Standard_D16s_v3",
"memory": 64.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.536,
"burstable": false,
"instanceType": "Standard_D32s_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.02,
"burstable": false,
"instanceType": "Standard_A0",
"memory": 0.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.023,
"burstable": false,
"instanceType": "Standard_A1",
"memory": 1.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.079,
"burstable": false,
"instanceType": "Standard_A2",
"memory": 3.5,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.176,
"burstable": false,
"instanceType": "Standard_A3",
"memory": 7.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.25,
"burstable": false,
"instanceType": "Standard_A5",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.352,
"burstable": false,
"instanceType": "Standard_A4",
"memory": 14.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.5,
"burstable": false,
"instanceType": "Standard_A6",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.0,
"burstable": false,
"instanceType": "Standard_A7",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.073,
"burstable": false,
"instanceType": "Standard_D1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.146,
"burstable": false,
"instanceType": "Standard_D2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.293,
"burstable": false,
"instanceType": "Standard_D3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.585,
"burstable": false,
"instanceType": "Standard_D4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.17,
"burstable": false,
"instanceType": "Standard_D5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.185,
"burstable": false,
"instanceType": "Standard_D11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.371,
"burstable": false,
"instanceType": "Standard_D12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.741,
"burstable": false,
"instanceType": "Standard_D13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.482,
"burstable": false,
"instanceType": "Standard_D14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.853,
"burstable": false,
"instanceType": "Standard_D15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.146,
"burstable": false,
"instanceType": "Standard_D2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.293,
"burstable": false,
"instanceType": "Standard_D3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.585,
"burstable": false,
"instanceType": "Standard_D4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.17,
"burstable": false,
"instanceType": "Standard_D5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.185,
"burstable": false,
"instanceType": "Standard_D11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.371,
"burstable": false,
"instanceType": "Standard_D12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.741,
"burstable": false,
"instanceType": "Standard_D13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.482,
"burstable": false,
"instanceType": "Standard_D14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.05,
"burstable": false,
"instanceType": "Standard_F1",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.099,
"burstable": false,
"instanceType": "Standard_F2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.199,
"burstable": false,
"instanceType": "Standard_F4",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.398,
"burstable": false,
"instanceType": "Standard_F8",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.796,
"burstable": false,
"instanceType": "Standard_F16",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.043,
"burstable": false,
"instanceType": "Standard_A1_v2",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.119,
"burstable": false,
"instanceType": "Standard_A2m_v2",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.091,
"burstable": false,
"instanceType": "Standard_A2_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.238,
"burstable": false,
"instanceType": "Standard_A4m_v2",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.191,
"burstable": false,
"instanceType": "Standard_A4_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.475,
"burstable": false,
"instanceType": "Standard_A8m_v2",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.4,
"burstable": false,
"instanceType": "Standard_A8_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.096,
"burstable": false,
"instanceType": "Standard_D2_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.192,
"burstable": false,
"instanceType": "Standard_D4_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.384,
"burstable": false,
"instanceType": "Standard_D8_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.768,
"burstable": false,
"instanceType": "Standard_D16_v3",
"memory": 64.1,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.536,
"burstable": false,
"instanceType": "Standard_D32_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.072,
"burstable": false,
"instanceType": "Standard_D64_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.072,
"burstable": false,
"instanceType": "Standard_D64s_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.126,
"burstable": false,
"instanceType": "Standard_E2_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.252,
"burstable": false,
"instanceType": "Standard_E4_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.504,
"burstable": false,
"instanceType": "Standard_E8_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.008,
"burstable": false,
"instanceType": "Standard_E16_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.26,
"burstable": false,
"instanceType": "Standard_E20_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.016,
"burstable": false,
"instanceType": "Standard_E32_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.629,
"burstable": false,
"instanceType": "Standard_E64i_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.629,
"burstable": false,
"instanceType": "Standard_E64_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.126,
"burstable": false,
"instanceType": "Standard_E2s_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.252,
"burstable": false,
"instanceType": "Standard_E4s_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.504,
"burstable": false,
"instanceType": "Standard_E8s_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.008,
"burstable": false,
"instanceType": "Standard_E16s_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.26,
"burstable": false,
"instanceType": "Standard_E20s_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.016,
"burstable": false,
"instanceType": "Standard_E32s_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.629,
"burstable": false,
"instanceType": "Standard_E64is_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.629,
"burstable": false,
"instanceType": "Standard_E64s_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.904,
"burstable": false,
"instanceType": "Standard_H8",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.807,
"burstable": false,
"instanceType": "Standard_H16",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.211,
"burstable": false,
"instanceType": "Standard_H8m",
"memory": 112.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.422,
"burstable": false,
"instanceType": "Standard_H16m",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.988,
"burstable": false,
"instanceType": "Standard_H16r",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.664,
"burstable": false,
"instanceType": "Standard_H16mr",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.077,
"burstable": false,
"instanceType": "Standard_D1",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.154,
"burstable": false,
"instanceType": "Standard_D2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.308,
"burstable": false,
"instanceType": "Standard_D3",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.616,
"burstable": false,
"instanceType": "Standard_D4",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.193,
"burstable": false,
"instanceType": "Standard_D11",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.386,
"burstable": false,
"instanceType": "Standard_D12",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.771,
"burstable": false,
"instanceType": "Standard_D13",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.542,
"burstable": false,
"instanceType": "Standard_D14",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.14,
"burstable": false,
"instanceType": "Standard_NV6",
"memory": 56.0,
"cpu": 6
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.28,
"burstable": false,
"instanceType": "Standard_NV12",
"memory": 112.0,
"cpu": 12
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.56,
"burstable": false,
"instanceType": "Standard_NV24",
"memory": 224.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.07,
"burstable": false,
"instanceType": "Standard_NC6s_v2",
"memory": 112.0,
"cpu": 6
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.14,
"burstable": false,
"instanceType": "Standard_NC12s_v2",
"memory": 224.0,
"cpu": 12
},
{
"baseline": 1.0,
"generation": "current",
"price": 9.108,
"burstable": false,
"instanceType": "Standard_NC24rs_v2",
"memory": 448.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 8.28,
"burstable": false,
"instanceType": "Standard_NC24s_v2",
"memory": 448.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.9,
"burstable": false,
"instanceType": "Standard_NC6",
"memory": 56.0,
"cpu": 6
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.8,
"burstable": false,
"instanceType": "Standard_NC12",
"memory": 112.0,
"cpu": 12
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.6,
"burstable": false,
"instanceType": "Standard_NC24",
"memory": 224.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.085,
"burstable": false,
"instanceType": "Standard_F2s_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.169,
"burstable": false,
"instanceType": "Standard_F4s_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.338,
"burstable": false,
"instanceType": "Standard_F8s_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.677,
"burstable": false,
"instanceType": "Standard_F16s_v2",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.353,
"burstable": false,
"instanceType": "Standard_F32s_v2",
"memory": 64.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.706,
"burstable": false,
"instanceType": "Standard_F64s_v2",
"memory": 128.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.045,
"burstable": false,
"instanceType": "Standard_F72s_v2",
"memory": 144.0,
"cpu": 72
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.077,
"burstable": false,
"instanceType": "Standard_DS1",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.154,
"burstable": false,
"instanceType": "Standard_DS2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.308,
"burstable": false,
"instanceType": "Standard_DS3",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.616,
"burstable": false,
"instanceType": "Standard_DS4",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.193,
"burstable": false,
"instanceType": "Standard_DS11",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.386,
"burstable": false,
"instanceType": "Standard_DS12",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.771,
"burstable": false,
"instanceType": "Standard_DS13",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.542,
"burstable": false,
"instanceType": "Standard_DS14",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.07,
"burstable": false,
"instanceType": "Standard_ND6s",
"memory": 112.0,
"cpu": 6
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.14,
"burstable": false,
"instanceType": "Standard_ND12s",
"memory": 224.0,
"cpu": 12
},
{
"baseline": 1.0,
"generation": "current",
"price": 9.108,
"burstable": false,
"instanceType": "Standard_ND24rs",
"memory": 448.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 8.28,
"burstable": false,
"instanceType": "Standard_ND24s",
"memory": 448.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.198,
"burstable": false,
"instanceType": "Standard_DC2s",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.395,
"burstable": false,
"instanceType": "Standard_DC4s",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.06,
"burstable": false,
"instanceType": "Standard_NC6s_v3",
"memory": 112.0,
"cpu": 6
},
{
"baseline": 1.0,
"generation": "current",
"price": 6.12,
"burstable": false,
"instanceType": "Standard_NC12s_v3",
"memory": 224.0,
"cpu": 12
},
{
"baseline": 1.0,
"generation": "current",
"price": 13.464,
"burstable": false,
"instanceType": "Standard_NC24rs_v3",
"memory": 448.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 12.24,
"burstable": false,
"instanceType": "Standard_NC24s_v3",
"memory": 448.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.312,
"burstable": false,
"instanceType": "Standard_L8s_v2",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.624,
"burstable": false,
"instanceType": "Standard_L16s_v2",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 6.24,
"burstable": false,
"instanceType": "Standard_L80s_v2",
"memory": 640.0,
"cpu": 80
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.975,
"burstable": false,
"instanceType": "Standard_A8",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.95,
"burstable": false,
"instanceType": "Standard_A9",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.78,
"burstable": false,
"instanceType": "Standard_A10",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.56,
"burstable": false,
"instanceType": "Standard_A11",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.5365,
"burstable": false,
"instanceType": "Standard_M8ms",
"memory": 218.75,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.073,
"burstable": false,
"instanceType": "Standard_M16ms",
"memory": 437.5,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.873,
"burstable": false,
"instanceType": "Standard_M32ls",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 6.146,
"burstable": false,
"instanceType": "Standard_M32ms",
"memory": 875.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.707,
"burstable": false,
"instanceType": "Standard_M32ts",
"memory": 192.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.415,
"burstable": false,
"instanceType": "Standard_M64ls",
"memory": 512.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 10.337,
"burstable": false,
"instanceType": "Standard_M64ms",
"memory": 1750.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 6.669,
"burstable": false,
"instanceType": "Standard_M64s",
"memory": 1000.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 26.688,
"burstable": false,
"instanceType": "Standard_M128ms",
"memory": 3800.0,
"cpu": 128
},
{
"baseline": 1.0,
"generation": "current",
"price": 13.338,
"burstable": false,
"instanceType": "Standard_M128s",
"memory": 2000.0,
"cpu": 128
}
],
"Canada Central": [
{
"baseline": 0.2,
"generation": "current",
"price": 0.023,
"burstable": true,
"instanceType": "Standard_B1ms",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 0.1,
"generation": "current",
"price": 0.0116,
"burstable": true,
"instanceType": "Standard_B1s",
"memory": 1.0,
"cpu": 1
},
{
"baseline": 0.6,
"generation": "current",
"price": 0.0928,
"burstable": true,
"instanceType": "Standard_B2ms",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 0.4,
"generation": "current",
"price": 0.0464,
"burstable": true,
"instanceType": "Standard_B2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 0.9,
"generation": "current",
"price": 0.185,
"burstable": true,
"instanceType": "Standard_B4ms",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.35,
"generation": "current",
"price": 0.371,
"burstable": true,
"instanceType": "Standard_B8ms",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.076,
"burstable": false,
"instanceType": "Standard_D1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.152,
"burstable": false,
"instanceType": "Standard_D2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.305,
"burstable": false,
"instanceType": "Standard_D3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.61,
"burstable": false,
"instanceType": "Standard_D4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.22,
"burstable": false,
"instanceType": "Standard_D5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.199,
"burstable": false,
"instanceType": "Standard_D11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.399,
"burstable": false,
"instanceType": "Standard_D12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.798,
"burstable": false,
"instanceType": "Standard_D13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.596,
"burstable": false,
"instanceType": "Standard_D14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.152,
"burstable": false,
"instanceType": "Standard_D2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.305,
"burstable": false,
"instanceType": "Standard_D3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.61,
"burstable": false,
"instanceType": "Standard_D4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.22,
"burstable": false,
"instanceType": "Standard_D5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.199,
"burstable": false,
"instanceType": "Standard_D11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.399,
"burstable": false,
"instanceType": "Standard_D12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.798,
"burstable": false,
"instanceType": "Standard_D13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.596,
"burstable": false,
"instanceType": "Standard_D14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.052,
"burstable": false,
"instanceType": "Standard_F1",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.104,
"burstable": false,
"instanceType": "Standard_F2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.207,
"burstable": false,
"instanceType": "Standard_F4",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.415,
"burstable": false,
"instanceType": "Standard_F8",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.83,
"burstable": false,
"instanceType": "Standard_F16",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.076,
"burstable": false,
"instanceType": "Standard_DS1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.152,
"burstable": false,
"instanceType": "Standard_DS2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.305,
"burstable": false,
"instanceType": "Standard_DS3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.61,
"burstable": false,
"instanceType": "Standard_DS4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.22,
"burstable": false,
"instanceType": "Standard_DS5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.199,
"burstable": false,
"instanceType": "Standard_DS11-1_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.199,
"burstable": false,
"instanceType": "Standard_DS11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.399,
"burstable": false,
"instanceType": "Standard_DS12-1_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.399,
"burstable": false,
"instanceType": "Standard_DS12-2_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.399,
"burstable": false,
"instanceType": "Standard_DS12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.798,
"burstable": false,
"instanceType": "Standard_DS13-2_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.798,
"burstable": false,
"instanceType": "Standard_DS13-4_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.798,
"burstable": false,
"instanceType": "Standard_DS13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.596,
"burstable": false,
"instanceType": "Standard_DS14-4_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.596,
"burstable": false,
"instanceType": "Standard_DS14-8_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.596,
"burstable": false,
"instanceType": "Standard_DS14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.152,
"burstable": false,
"instanceType": "Standard_DS2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.305,
"burstable": false,
"instanceType": "Standard_DS3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.61,
"burstable": false,
"instanceType": "Standard_DS4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.22,
"burstable": false,
"instanceType": "Standard_DS5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.199,
"burstable": false,
"instanceType": "Standard_DS11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.399,
"burstable": false,
"instanceType": "Standard_DS12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.798,
"burstable": false,
"instanceType": "Standard_DS13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.596,
"burstable": false,
"instanceType": "Standard_DS14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.052,
"burstable": false,
"instanceType": "Standard_F1s",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.104,
"burstable": false,
"instanceType": "Standard_F2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.207,
"burstable": false,
"instanceType": "Standard_F4s",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.415,
"burstable": false,
"instanceType": "Standard_F8s",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.83,
"burstable": false,
"instanceType": "Standard_F16s",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.047,
"burstable": false,
"instanceType": "Standard_A1_v2",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.168,
"burstable": false,
"instanceType": "Standard_A2m_v2",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.098,
"burstable": false,
"instanceType": "Standard_A2_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.353,
"burstable": false,
"instanceType": "Standard_A4m_v2",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.206,
"burstable": false,
"instanceType": "Standard_A4_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.742,
"burstable": false,
"instanceType": "Standard_A8m_v2",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.433,
"burstable": false,
"instanceType": "Standard_A8_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.111,
"burstable": false,
"instanceType": "Standard_D2_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.222,
"burstable": false,
"instanceType": "Standard_D4_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.444,
"burstable": false,
"instanceType": "Standard_D8_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.888,
"burstable": false,
"instanceType": "Standard_D16_v3",
"memory": 64.1,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.776,
"burstable": false,
"instanceType": "Standard_D32_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.552,
"burstable": false,
"instanceType": "Standard_D64_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.111,
"burstable": false,
"instanceType": "Standard_D2s_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.222,
"burstable": false,
"instanceType": "Standard_D4s_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.444,
"burstable": false,
"instanceType": "Standard_D8s_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.888,
"burstable": false,
"instanceType": "Standard_D16s_v3",
"memory": 64.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.776,
"burstable": false,
"instanceType": "Standard_D32s_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.552,
"burstable": false,
"instanceType": "Standard_D64s_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.146,
"burstable": false,
"instanceType": "Standard_E2_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.292,
"burstable": false,
"instanceType": "Standard_E4_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.584,
"burstable": false,
"instanceType": "Standard_E8_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.168,
"burstable": false,
"instanceType": "Standard_E16_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.336,
"burstable": false,
"instanceType": "Standard_E32_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.974,
"burstable": false,
"instanceType": "Standard_E64i_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.974,
"burstable": false,
"instanceType": "Standard_E64_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.146,
"burstable": false,
"instanceType": "Standard_E2s_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.292,
"burstable": false,
"instanceType": "Standard_E4s_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.584,
"burstable": false,
"instanceType": "Standard_E8s_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.168,
"burstable": false,
"instanceType": "Standard_E16s_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.336,
"burstable": false,
"instanceType": "Standard_E32s_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.974,
"burstable": false,
"instanceType": "Standard_E64is_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.974,
"burstable": false,
"instanceType": "Standard_E64s_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.995,
"burstable": false,
"instanceType": "Standard_DS15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.093,
"burstable": false,
"instanceType": "Standard_F2s_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.186,
"burstable": false,
"instanceType": "Standard_F4s_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.372,
"burstable": false,
"instanceType": "Standard_F8s_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.744,
"burstable": false,
"instanceType": "Standard_F16s_v2",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.488,
"burstable": false,
"instanceType": "Standard_F32s_v2",
"memory": 64.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.976,
"burstable": false,
"instanceType": "Standard_F64s_v2",
"memory": 128.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.348,
"burstable": false,
"instanceType": "Standard_F72s_v2",
"memory": 144.0,
"cpu": 72
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.024,
"burstable": false,
"instanceType": "Standard_A0",
"memory": 0.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.061,
"burstable": false,
"instanceType": "Standard_A1",
"memory": 1.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.121,
"burstable": false,
"instanceType": "Standard_A2",
"memory": 3.5,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.242,
"burstable": false,
"instanceType": "Standard_A3",
"memory": 7.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.264,
"burstable": false,
"instanceType": "Standard_A5",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.486,
"burstable": false,
"instanceType": "Standard_A4",
"memory": 14.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.528,
"burstable": false,
"instanceType": "Standard_A6",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.056,
"burstable": false,
"instanceType": "Standard_A7",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.995,
"burstable": false,
"instanceType": "Standard_D15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.46,
"burstable": false,
"instanceType": "Standard_E20_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.46,
"burstable": false,
"instanceType": "Standard_E20s_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.528,
"burstable": false,
"instanceType": "Standard_G1",
"memory": 28.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.056,
"burstable": false,
"instanceType": "Standard_G2",
"memory": 56.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.112,
"burstable": false,
"instanceType": "Standard_G3",
"memory": 112.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.224,
"burstable": false,
"instanceType": "Standard_G4",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 8.448,
"burstable": false,
"instanceType": "Standard_G5",
"memory": 448.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.528,
"burstable": false,
"instanceType": "Standard_GS1",
"memory": 28.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.056,
"burstable": false,
"instanceType": "Standard_GS2",
"memory": 56.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.112,
"burstable": false,
"instanceType": "Standard_GS3",
"memory": 112.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.224,
"burstable": false,
"instanceType": "Standard_GS4",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.224,
"burstable": false,
"instanceType": "Standard_GS4-4",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.224,
"burstable": false,
"instanceType": "Standard_GS4-8",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 8.448,
"burstable": false,
"instanceType": "Standard_GS5",
"memory": 448.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 8.448,
"burstable": false,
"instanceType": "Standard_GS5-8",
"memory": 448.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 8.448,
"burstable": false,
"instanceType": "Standard_GS5-16",
"memory": 448.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.344,
"burstable": false,
"instanceType": "Standard_L4s",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.688,
"burstable": false,
"instanceType": "Standard_L8s",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.376,
"burstable": false,
"instanceType": "Standard_L16s",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.752,
"burstable": false,
"instanceType": "Standard_L32s",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.69015,
"burstable": false,
"instanceType": "Standard_M8ms",
"memory": 218.75,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.3803,
"burstable": false,
"instanceType": "Standard_M16ms",
"memory": 437.5,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.1603,
"burstable": false,
"instanceType": "Standard_M32ls",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 6.7606,
"burstable": false,
"instanceType": "Standard_M32ms",
"memory": 875.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.9777,
"burstable": false,
"instanceType": "Standard_M32ts",
"memory": 192.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.9565,
"burstable": false,
"instanceType": "Standard_M64ls",
"memory": 512.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 11.3707,
"burstable": false,
"instanceType": "Standard_M64ms",
"memory": 1750.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 7.3359,
"burstable": false,
"instanceType": "Standard_M64s",
"memory": 1000.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 29.3568,
"burstable": false,
"instanceType": "Standard_M128ms",
"memory": 3800.0,
"cpu": 128
},
{
"baseline": 1.0,
"generation": "current",
"price": 14.6718,
"burstable": false,
"instanceType": "Standard_M128s",
"memory": 2000.0,
"cpu": 128
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.672,
"burstable": false,
"instanceType": "Standard_NC6s_v3",
"memory": 112.0,
"cpu": 6
},
{
"baseline": 1.0,
"generation": "current",
"price": 7.344,
"burstable": false,
"instanceType": "Standard_NC12s_v3",
"memory": 224.0,
"cpu": 12
},
{
"baseline": 1.0,
"generation": "current",
"price": 16.157,
"burstable": false,
"instanceType": "Standard_NC24rs_v3",
"memory": 448.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 14.688,
"burstable": false,
"instanceType": "Standard_NC24s_v3",
"memory": 448.0,
"cpu": 24
}
],
"South India": [
{
"baseline": 1.0,
"generation": "current",
"price": 0.016,
"burstable": false,
"instanceType": "Standard_A0",
"memory": 0.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.033,
"burstable": false,
"instanceType": "Standard_A1",
"memory": 1.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.118,
"burstable": false,
"instanceType": "Standard_A2",
"memory": 3.5,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.236,
"burstable": false,
"instanceType": "Standard_A3",
"memory": 7.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.234,
"burstable": false,
"instanceType": "Standard_A5",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.418,
"burstable": false,
"instanceType": "Standard_A4",
"memory": 14.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.468,
"burstable": false,
"instanceType": "Standard_A6",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.936,
"burstable": false,
"instanceType": "Standard_A7",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.084,
"burstable": false,
"instanceType": "Standard_D1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.169,
"burstable": false,
"instanceType": "Standard_D2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.337,
"burstable": false,
"instanceType": "Standard_D3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.675,
"burstable": false,
"instanceType": "Standard_D4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.35,
"burstable": false,
"instanceType": "Standard_D5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.189,
"burstable": false,
"instanceType": "Standard_D11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.379,
"burstable": false,
"instanceType": "Standard_D12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.758,
"burstable": false,
"instanceType": "Standard_D13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.516,
"burstable": false,
"instanceType": "Standard_D14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.895,
"burstable": false,
"instanceType": "Standard_D15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.169,
"burstable": false,
"instanceType": "Standard_D2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.337,
"burstable": false,
"instanceType": "Standard_D3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.675,
"burstable": false,
"instanceType": "Standard_D4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.35,
"burstable": false,
"instanceType": "Standard_D5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.189,
"burstable": false,
"instanceType": "Standard_D11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.379,
"burstable": false,
"instanceType": "Standard_D12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.758,
"burstable": false,
"instanceType": "Standard_D13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.516,
"burstable": false,
"instanceType": "Standard_D14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.06,
"burstable": false,
"instanceType": "Standard_F1",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.121,
"burstable": false,
"instanceType": "Standard_F2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.242,
"burstable": false,
"instanceType": "Standard_F4",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.483,
"burstable": false,
"instanceType": "Standard_F8",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.966,
"burstable": false,
"instanceType": "Standard_F16",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.047,
"burstable": false,
"instanceType": "Standard_A1_v2",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.144,
"burstable": false,
"instanceType": "Standard_A2m_v2",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.098,
"burstable": false,
"instanceType": "Standard_A2_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.301,
"burstable": false,
"instanceType": "Standard_A4m_v2",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.206,
"burstable": false,
"instanceType": "Standard_A4_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.633,
"burstable": false,
"instanceType": "Standard_A8m_v2",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.433,
"burstable": false,
"instanceType": "Standard_A8_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 0.2,
"generation": "current",
"price": 0.0294,
"burstable": true,
"instanceType": "Standard_B1ms",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 0.1,
"generation": "current",
"price": 0.0145,
"burstable": true,
"instanceType": "Standard_B1s",
"memory": 1.0,
"cpu": 1
},
{
"baseline": 0.6,
"generation": "current",
"price": 0.118,
"burstable": true,
"instanceType": "Standard_B2ms",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 0.4,
"generation": "current",
"price": 0.058,
"burstable": true,
"instanceType": "Standard_B2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 0.9,
"generation": "current",
"price": 0.236,
"burstable": true,
"instanceType": "Standard_B4ms",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.35,
"generation": "current",
"price": 0.471,
"burstable": true,
"instanceType": "Standard_B8ms",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.084,
"burstable": false,
"instanceType": "Standard_DS1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.169,
"burstable": false,
"instanceType": "Standard_DS2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.337,
"burstable": false,
"instanceType": "Standard_DS3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.675,
"burstable": false,
"instanceType": "Standard_DS4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.35,
"burstable": false,
"instanceType": "Standard_DS5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.189,
"burstable": false,
"instanceType": "Standard_DS11-1_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.189,
"burstable": false,
"instanceType": "Standard_DS11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.379,
"burstable": false,
"instanceType": "Standard_DS12-1_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.379,
"burstable": false,
"instanceType": "Standard_DS12-2_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.379,
"burstable": false,
"instanceType": "Standard_DS12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.758,
"burstable": false,
"instanceType": "Standard_DS13-2_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.758,
"burstable": false,
"instanceType": "Standard_DS13-4_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.758,
"burstable": false,
"instanceType": "Standard_DS13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.516,
"burstable": false,
"instanceType": "Standard_DS14-4_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.516,
"burstable": false,
"instanceType": "Standard_DS14-8_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.516,
"burstable": false,
"instanceType": "Standard_DS14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.169,
"burstable": false,
"instanceType": "Standard_DS2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.337,
"burstable": false,
"instanceType": "Standard_DS3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.675,
"burstable": false,
"instanceType": "Standard_DS4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.35,
"burstable": false,
"instanceType": "Standard_DS5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.189,
"burstable": false,
"instanceType": "Standard_DS11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.379,
"burstable": false,
"instanceType": "Standard_DS12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.758,
"burstable": false,
"instanceType": "Standard_DS13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.516,
"burstable": false,
"instanceType": "Standard_DS14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.06,
"burstable": false,
"instanceType": "Standard_F1s",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.121,
"burstable": false,
"instanceType": "Standard_F2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.242,
"burstable": false,
"instanceType": "Standard_F4s",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.483,
"burstable": false,
"instanceType": "Standard_F8s",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.966,
"burstable": false,
"instanceType": "Standard_F16s",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.135,
"burstable": false,
"instanceType": "Standard_D2_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.271,
"burstable": false,
"instanceType": "Standard_D4_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.541,
"burstable": false,
"instanceType": "Standard_D8_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.082,
"burstable": false,
"instanceType": "Standard_D16_v3",
"memory": 64.1,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.164,
"burstable": false,
"instanceType": "Standard_D32_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.328,
"burstable": false,
"instanceType": "Standard_D64_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.135,
"burstable": false,
"instanceType": "Standard_D2s_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.271,
"burstable": false,
"instanceType": "Standard_D4s_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.541,
"burstable": false,
"instanceType": "Standard_D8s_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.082,
"burstable": false,
"instanceType": "Standard_D16s_v3",
"memory": 64.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.164,
"burstable": false,
"instanceType": "Standard_D32s_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.328,
"burstable": false,
"instanceType": "Standard_D64s_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.167,
"burstable": false,
"instanceType": "Standard_E2_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.334,
"burstable": false,
"instanceType": "Standard_E4_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.669,
"burstable": false,
"instanceType": "Standard_E8_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.338,
"burstable": false,
"instanceType": "Standard_E16_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.67,
"burstable": false,
"instanceType": "Standard_E20_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.675,
"burstable": false,
"instanceType": "Standard_E32_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.801,
"burstable": false,
"instanceType": "Standard_E64i_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.801,
"burstable": false,
"instanceType": "Standard_E64_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.167,
"burstable": false,
"instanceType": "Standard_E2s_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.334,
"burstable": false,
"instanceType": "Standard_E4s_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.669,
"burstable": false,
"instanceType": "Standard_E8s_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.338,
"burstable": false,
"instanceType": "Standard_E16s_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.67,
"burstable": false,
"instanceType": "Standard_E20s_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.675,
"burstable": false,
"instanceType": "Standard_E32s_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.801,
"burstable": false,
"instanceType": "Standard_E64is_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.801,
"burstable": false,
"instanceType": "Standard_E64s_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.0935,
"burstable": false,
"instanceType": "Standard_F2s_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.187,
"burstable": false,
"instanceType": "Standard_F4s_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.374,
"burstable": false,
"instanceType": "Standard_F8s_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.748,
"burstable": false,
"instanceType": "Standard_F16s_v2",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.496,
"burstable": false,
"instanceType": "Standard_F32s_v2",
"memory": 64.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.992,
"burstable": false,
"instanceType": "Standard_F64s_v2",
"memory": 128.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.366,
"burstable": false,
"instanceType": "Standard_F72s_v2",
"memory": 144.0,
"cpu": 72
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.895,
"burstable": false,
"instanceType": "Standard_DS15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.3278,
"burstable": false,
"instanceType": "Standard_M8ms",
"memory": 218.75,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.6556,
"burstable": false,
"instanceType": "Standard_M16ms",
"memory": 437.5,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.61998,
"burstable": false,
"instanceType": "Standard_M32ls",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 9.3112,
"burstable": false,
"instanceType": "Standard_M32ms",
"memory": 875.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.41082,
"burstable": false,
"instanceType": "Standard_M32ts",
"memory": 192.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 6.8229,
"burstable": false,
"instanceType": "Standard_M64ls",
"memory": 512.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 15.664,
"burstable": false,
"instanceType": "Standard_M64ms",
"memory": 1750.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 10.106,
"burstable": false,
"instanceType": "Standard_M64s",
"memory": 1000.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 40.441,
"burstable": false,
"instanceType": "Standard_M128ms",
"memory": 3800.0,
"cpu": 128
},
{
"baseline": 1.0,
"generation": "current",
"price": 20.211,
"burstable": false,
"instanceType": "Standard_M128s",
"memory": 2000.0,
"cpu": 128
}
],
"West Europe": [
{
"baseline": 1.0,
"generation": "current",
"price": 0.02,
"burstable": false,
"instanceType": "Standard_A0",
"memory": 0.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.06,
"burstable": false,
"instanceType": "Standard_A1",
"memory": 1.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.078,
"burstable": false,
"instanceType": "Standard_A2",
"memory": 3.5,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.24,
"burstable": false,
"instanceType": "Standard_A3",
"memory": 7.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.27,
"burstable": false,
"instanceType": "Standard_A5",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.408,
"burstable": false,
"instanceType": "Standard_A4",
"memory": 14.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.54,
"burstable": false,
"instanceType": "Standard_A6",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.08,
"burstable": false,
"instanceType": "Standard_A7",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.084,
"burstable": false,
"instanceType": "Standard_D1",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.168,
"burstable": false,
"instanceType": "Standard_D2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.336,
"burstable": false,
"instanceType": "Standard_D3",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.672,
"burstable": false,
"instanceType": "Standard_D4",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.221,
"burstable": false,
"instanceType": "Standard_D11",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.442,
"burstable": false,
"instanceType": "Standard_D12",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.885,
"burstable": false,
"instanceType": "Standard_D13",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.769,
"burstable": false,
"instanceType": "Standard_D14",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.041,
"burstable": false,
"instanceType": "Standard_A1_v2",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.124,
"burstable": false,
"instanceType": "Standard_A2m_v2",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.087,
"burstable": false,
"instanceType": "Standard_A2_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.26,
"burstable": false,
"instanceType": "Standard_A4m_v2",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.183,
"burstable": false,
"instanceType": "Standard_A4_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.546,
"burstable": false,
"instanceType": "Standard_A8m_v2",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.383,
"burstable": false,
"instanceType": "Standard_A8_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.084,
"burstable": false,
"instanceType": "Standard_DS1",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.168,
"burstable": false,
"instanceType": "Standard_DS2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.336,
"burstable": false,
"instanceType": "Standard_DS3",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.672,
"burstable": false,
"instanceType": "Standard_DS4",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.221,
"burstable": false,
"instanceType": "Standard_DS11",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.442,
"burstable": false,
"instanceType": "Standard_DS12",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.885,
"burstable": false,
"instanceType": "Standard_DS13",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.769,
"burstable": false,
"instanceType": "Standard_DS14",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.068,
"burstable": false,
"instanceType": "Standard_D1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.136,
"burstable": false,
"instanceType": "Standard_D2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.272,
"burstable": false,
"instanceType": "Standard_D3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.544,
"burstable": false,
"instanceType": "Standard_D4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.087,
"burstable": false,
"instanceType": "Standard_D5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.19,
"burstable": false,
"instanceType": "Standard_D11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.379,
"burstable": false,
"instanceType": "Standard_D12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.759,
"burstable": false,
"instanceType": "Standard_D13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.518,
"burstable": false,
"instanceType": "Standard_D14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.897,
"burstable": false,
"instanceType": "Standard_D15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.136,
"burstable": false,
"instanceType": "Standard_D2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.272,
"burstable": false,
"instanceType": "Standard_D3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.544,
"burstable": false,
"instanceType": "Standard_D4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.087,
"burstable": false,
"instanceType": "Standard_D5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.19,
"burstable": false,
"instanceType": "Standard_D11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.379,
"burstable": false,
"instanceType": "Standard_D12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.759,
"burstable": false,
"instanceType": "Standard_D13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.518,
"burstable": false,
"instanceType": "Standard_D14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.057,
"burstable": false,
"instanceType": "Standard_F1",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.114,
"burstable": false,
"instanceType": "Standard_F2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.227,
"burstable": false,
"instanceType": "Standard_F4",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.454,
"burstable": false,
"instanceType": "Standard_F8",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.909,
"burstable": false,
"instanceType": "Standard_F16",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 0.2,
"generation": "current",
"price": 0.024,
"burstable": true,
"instanceType": "Standard_B1ms",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 0.1,
"generation": "current",
"price": 0.012,
"burstable": true,
"instanceType": "Standard_B1s",
"memory": 1.0,
"cpu": 1
},
{
"baseline": 0.6,
"generation": "current",
"price": 0.096,
"burstable": true,
"instanceType": "Standard_B2ms",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 0.4,
"generation": "current",
"price": 0.048,
"burstable": true,
"instanceType": "Standard_B2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 0.9,
"generation": "current",
"price": 0.192,
"burstable": true,
"instanceType": "Standard_B4ms",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.35,
"generation": "current",
"price": 0.384,
"burstable": true,
"instanceType": "Standard_B8ms",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.068,
"burstable": false,
"instanceType": "Standard_DS1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.136,
"burstable": false,
"instanceType": "Standard_DS2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.272,
"burstable": false,
"instanceType": "Standard_DS3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.544,
"burstable": false,
"instanceType": "Standard_DS4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.087,
"burstable": false,
"instanceType": "Standard_DS5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.19,
"burstable": false,
"instanceType": "Standard_DS11-1_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.19,
"burstable": false,
"instanceType": "Standard_DS11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.379,
"burstable": false,
"instanceType": "Standard_DS12-1_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.379,
"burstable": false,
"instanceType": "Standard_DS12-2_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.379,
"burstable": false,
"instanceType": "Standard_DS12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.759,
"burstable": false,
"instanceType": "Standard_DS13-2_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.759,
"burstable": false,
"instanceType": "Standard_DS13-4_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.759,
"burstable": false,
"instanceType": "Standard_DS13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.518,
"burstable": false,
"instanceType": "Standard_DS14-4_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.518,
"burstable": false,
"instanceType": "Standard_DS14-8_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.518,
"burstable": false,
"instanceType": "Standard_DS14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.897,
"burstable": false,
"instanceType": "Standard_DS15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.136,
"burstable": false,
"instanceType": "Standard_DS2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.272,
"burstable": false,
"instanceType": "Standard_DS3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.544,
"burstable": false,
"instanceType": "Standard_DS4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.087,
"burstable": false,
"instanceType": "Standard_DS5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.19,
"burstable": false,
"instanceType": "Standard_DS11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.379,
"burstable": false,
"instanceType": "Standard_DS12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.759,
"burstable": false,
"instanceType": "Standard_DS13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.518,
"burstable": false,
"instanceType": "Standard_DS14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.057,
"burstable": false,
"instanceType": "Standard_F1s",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.114,
"burstable": false,
"instanceType": "Standard_F2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.227,
"burstable": false,
"instanceType": "Standard_F4s",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.454,
"burstable": false,
"instanceType": "Standard_F8s",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.909,
"burstable": false,
"instanceType": "Standard_F16s",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.12,
"burstable": false,
"instanceType": "Standard_D2_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.24,
"burstable": false,
"instanceType": "Standard_D4_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.48,
"burstable": false,
"instanceType": "Standard_D8_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.96,
"burstable": false,
"instanceType": "Standard_D16_v3",
"memory": 64.1,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.92,
"burstable": false,
"instanceType": "Standard_D32_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.12,
"burstable": false,
"instanceType": "Standard_D2s_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.24,
"burstable": false,
"instanceType": "Standard_D4s_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.48,
"burstable": false,
"instanceType": "Standard_D8s_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.96,
"burstable": false,
"instanceType": "Standard_D16s_v3",
"memory": 64.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.92,
"burstable": false,
"instanceType": "Standard_D32s_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.84,
"burstable": false,
"instanceType": "Standard_D64_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.16,
"burstable": false,
"instanceType": "Standard_E2_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.32,
"burstable": false,
"instanceType": "Standard_E4_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.64,
"burstable": false,
"instanceType": "Standard_E8_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.28,
"burstable": false,
"instanceType": "Standard_E16_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.6,
"burstable": false,
"instanceType": "Standard_E20_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.56,
"burstable": false,
"instanceType": "Standard_E32_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.376,
"burstable": false,
"instanceType": "Standard_E64i_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.376,
"burstable": false,
"instanceType": "Standard_E64_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.37,
"burstable": false,
"instanceType": "Standard_NV6",
"memory": 56.0,
"cpu": 6
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.73,
"burstable": false,
"instanceType": "Standard_NV12",
"memory": 112.0,
"cpu": 12
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.46,
"burstable": false,
"instanceType": "Standard_NV24",
"memory": 224.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.84,
"burstable": false,
"instanceType": "Standard_D64s_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.16,
"burstable": false,
"instanceType": "Standard_E2s_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.32,
"burstable": false,
"instanceType": "Standard_E4s_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.64,
"burstable": false,
"instanceType": "Standard_E8s_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.28,
"burstable": false,
"instanceType": "Standard_E16s_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.6,
"burstable": false,
"instanceType": "Standard_E20s_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.56,
"burstable": false,
"instanceType": "Standard_E32s_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.376,
"burstable": false,
"instanceType": "Standard_E64is_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.376,
"burstable": false,
"instanceType": "Standard_E64s_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.097,
"burstable": false,
"instanceType": "Standard_F2s_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.194,
"burstable": false,
"instanceType": "Standard_F4s_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.388,
"burstable": false,
"instanceType": "Standard_F8s_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.776,
"burstable": false,
"instanceType": "Standard_F16s_v2",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.552,
"burstable": false,
"instanceType": "Standard_F32s_v2",
"memory": 64.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.104,
"burstable": false,
"instanceType": "Standard_F64s_v2",
"memory": 128.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.492,
"burstable": false,
"instanceType": "Standard_F72s_v2",
"memory": 144.0,
"cpu": 72
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.978,
"burstable": false,
"instanceType": "Standard_NC6s_v3",
"memory": 112.0,
"cpu": 6
},
{
"baseline": 1.0,
"generation": "current",
"price": 7.956,
"burstable": false,
"instanceType": "Standard_NC12s_v3",
"memory": 224.0,
"cpu": 12
},
{
"baseline": 1.0,
"generation": "current",
"price": 17.5032,
"burstable": false,
"instanceType": "Standard_NC24rs_v3",
"memory": 448.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 15.912,
"burstable": false,
"instanceType": "Standard_NC24s_v3",
"memory": 448.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.7,
"burstable": false,
"instanceType": "Standard_G1",
"memory": 28.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.4,
"burstable": false,
"instanceType": "Standard_G2",
"memory": 56.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.8,
"burstable": false,
"instanceType": "Standard_G3",
"memory": 112.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.6,
"burstable": false,
"instanceType": "Standard_G4",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 9.99,
"burstable": false,
"instanceType": "Standard_G5",
"memory": 448.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.7,
"burstable": false,
"instanceType": "Standard_GS1",
"memory": 28.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.4,
"burstable": false,
"instanceType": "Standard_GS2",
"memory": 56.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.8,
"burstable": false,
"instanceType": "Standard_GS3",
"memory": 112.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.6,
"burstable": false,
"instanceType": "Standard_GS4",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.6,
"burstable": false,
"instanceType": "Standard_GS4-4",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.6,
"burstable": false,
"instanceType": "Standard_GS4-8",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 9.99,
"burstable": false,
"instanceType": "Standard_GS5",
"memory": 448.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 9.99,
"burstable": false,
"instanceType": "Standard_GS5-8",
"memory": 448.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 9.99,
"burstable": false,
"instanceType": "Standard_GS5-16",
"memory": 448.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.372,
"burstable": false,
"instanceType": "Standard_L4s",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.744,
"burstable": false,
"instanceType": "Standard_L8s",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.488,
"burstable": false,
"instanceType": "Standard_L16s",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.976,
"burstable": false,
"instanceType": "Standard_L32s",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.166,
"burstable": false,
"instanceType": "Standard_NC6",
"memory": 56.0,
"cpu": 6
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.333,
"burstable": false,
"instanceType": "Standard_NC12",
"memory": 112.0,
"cpu": 12
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.666,
"burstable": false,
"instanceType": "Standard_NC24",
"memory": 224.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.032,
"burstable": false,
"instanceType": "Standard_H8",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.065,
"burstable": false,
"instanceType": "Standard_H16",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.383,
"burstable": false,
"instanceType": "Standard_H8m",
"memory": 112.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.767,
"burstable": false,
"instanceType": "Standard_H16m",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.271,
"burstable": false,
"instanceType": "Standard_H16r",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.043,
"burstable": false,
"instanceType": "Standard_H16mr",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.1511,
"burstable": false,
"instanceType": "Standard_M8ms",
"memory": 218.75,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.3022,
"burstable": false,
"instanceType": "Standard_M16ms",
"memory": 437.5,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.4476,
"burstable": false,
"instanceType": "Standard_M32ls",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 8.6044,
"burstable": false,
"instanceType": "Standard_M32ms",
"memory": 875.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.2484,
"burstable": false,
"instanceType": "Standard_M32ts",
"memory": 192.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 6.498,
"burstable": false,
"instanceType": "Standard_M64ls",
"memory": 512.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 14.472,
"burstable": false,
"instanceType": "Standard_M64ms",
"memory": 1750.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 9.337,
"burstable": false,
"instanceType": "Standard_M64s",
"memory": 1000.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 37.3632,
"burstable": false,
"instanceType": "Standard_M128ms",
"memory": 3800.0,
"cpu": 128
},
{
"baseline": 1.0,
"generation": "current",
"price": 18.674,
"burstable": false,
"instanceType": "Standard_M128s",
"memory": 2000.0,
"cpu": 128
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.682,
"burstable": false,
"instanceType": "Standard_ND6s",
"memory": 112.0,
"cpu": 6
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.366,
"burstable": false,
"instanceType": "Standard_ND12s",
"memory": 224.0,
"cpu": 12
},
{
"baseline": 1.0,
"generation": "current",
"price": 11.804,
"burstable": false,
"instanceType": "Standard_ND24rs",
"memory": 448.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 10.732,
"burstable": false,
"instanceType": "Standard_ND24s",
"memory": 448.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.682,
"burstable": false,
"instanceType": "Standard_NC6s_v2",
"memory": 112.0,
"cpu": 6
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.366,
"burstable": false,
"instanceType": "Standard_NC12s_v2",
"memory": 224.0,
"cpu": 12
},
{
"baseline": 1.0,
"generation": "current",
"price": 11.804,
"burstable": false,
"instanceType": "Standard_NC24rs_v2",
"memory": 448.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 10.732,
"burstable": false,
"instanceType": "Standard_NC24s_v2",
"memory": 448.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.257,
"burstable": false,
"instanceType": "Standard_DC2s",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.514,
"burstable": false,
"instanceType": "Standard_DC4s",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.121,
"burstable": false,
"instanceType": "Standard_A8",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.243,
"burstable": false,
"instanceType": "Standard_A9",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.897,
"burstable": false,
"instanceType": "Standard_A10",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.794,
"burstable": false,
"instanceType": "Standard_A11",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.372,
"burstable": false,
"instanceType": "Standard_L8s_v2",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.744,
"burstable": false,
"instanceType": "Standard_L16s_v2",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 7.44,
"burstable": false,
"instanceType": "Standard_L80s_v2",
"memory": 640.0,
"cpu": 80
}
],
"Australia Central 2": [
{
"baseline": 0.2,
"generation": "current",
"price": 0.04,
"burstable": true,
"instanceType": "Standard_B1ms",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 0.1,
"generation": "current",
"price": 0.02,
"burstable": true,
"instanceType": "Standard_B1s",
"memory": 1.0,
"cpu": 1
},
{
"baseline": 0.6,
"generation": "current",
"price": 0.16,
"burstable": true,
"instanceType": "Standard_B2ms",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 0.4,
"generation": "current",
"price": 0.08,
"burstable": true,
"instanceType": "Standard_B2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 0.9,
"generation": "current",
"price": 0.32,
"burstable": true,
"instanceType": "Standard_B4ms",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.35,
"generation": "current",
"price": 0.64,
"burstable": true,
"instanceType": "Standard_B8ms",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.105,
"burstable": false,
"instanceType": "Standard_D1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.21,
"burstable": false,
"instanceType": "Standard_D2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.42,
"burstable": false,
"instanceType": "Standard_D3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.841,
"burstable": false,
"instanceType": "Standard_D4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.681,
"burstable": false,
"instanceType": "Standard_D5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.249,
"burstable": false,
"instanceType": "Standard_D11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.49875,
"burstable": false,
"instanceType": "Standard_D12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.997,
"burstable": false,
"instanceType": "Standard_D13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.995,
"burstable": false,
"instanceType": "Standard_D14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.21,
"burstable": false,
"instanceType": "Standard_D2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.42,
"burstable": false,
"instanceType": "Standard_D3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.841,
"burstable": false,
"instanceType": "Standard_D4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.681,
"burstable": false,
"instanceType": "Standard_D5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.249,
"burstable": false,
"instanceType": "Standard_D11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.49875,
"burstable": false,
"instanceType": "Standard_D12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.997,
"burstable": false,
"instanceType": "Standard_D13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.995,
"burstable": false,
"instanceType": "Standard_D14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.081,
"burstable": false,
"instanceType": "Standard_F1",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.162,
"burstable": false,
"instanceType": "Standard_F2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.325,
"burstable": false,
"instanceType": "Standard_F4",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.65,
"burstable": false,
"instanceType": "Standard_F8",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.3,
"burstable": false,
"instanceType": "Standard_F16",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.105,
"burstable": false,
"instanceType": "Standard_DS1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.21,
"burstable": false,
"instanceType": "Standard_DS2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.42,
"burstable": false,
"instanceType": "Standard_DS3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.841,
"burstable": false,
"instanceType": "Standard_DS4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.681,
"burstable": false,
"instanceType": "Standard_DS5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.249,
"burstable": false,
"instanceType": "Standard_DS11-1_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.249,
"burstable": false,
"instanceType": "Standard_DS11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.49875,
"burstable": false,
"instanceType": "Standard_DS12-1_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.49875,
"burstable": false,
"instanceType": "Standard_DS12-2_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.49875,
"burstable": false,
"instanceType": "Standard_DS12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.997,
"burstable": false,
"instanceType": "Standard_DS13-2_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.997,
"burstable": false,
"instanceType": "Standard_DS13-4_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.997,
"burstable": false,
"instanceType": "Standard_DS13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.995,
"burstable": false,
"instanceType": "Standard_DS14-4_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.995,
"burstable": false,
"instanceType": "Standard_DS14-8_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.995,
"burstable": false,
"instanceType": "Standard_DS14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.21,
"burstable": false,
"instanceType": "Standard_DS2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.42,
"burstable": false,
"instanceType": "Standard_DS3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.841,
"burstable": false,
"instanceType": "Standard_DS4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.681,
"burstable": false,
"instanceType": "Standard_DS5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.249,
"burstable": false,
"instanceType": "Standard_DS11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.49875,
"burstable": false,
"instanceType": "Standard_DS12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.997,
"burstable": false,
"instanceType": "Standard_DS13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.995,
"burstable": false,
"instanceType": "Standard_DS14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.081,
"burstable": false,
"instanceType": "Standard_F1s",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.162,
"burstable": false,
"instanceType": "Standard_F2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.325,
"burstable": false,
"instanceType": "Standard_F4s",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.65,
"burstable": false,
"instanceType": "Standard_F8s",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.3,
"burstable": false,
"instanceType": "Standard_F16s",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.0625,
"burstable": false,
"instanceType": "Standard_A1_v2",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.18625,
"burstable": false,
"instanceType": "Standard_A2m_v2",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.1325,
"burstable": false,
"instanceType": "Standard_A2_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.39,
"burstable": false,
"instanceType": "Standard_A4m_v2",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.2775,
"burstable": false,
"instanceType": "Standard_A4_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.81875,
"burstable": false,
"instanceType": "Standard_A8m_v2",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.58375,
"burstable": false,
"instanceType": "Standard_A8_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.15625,
"burstable": false,
"instanceType": "Standard_D2_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.3125,
"burstable": false,
"instanceType": "Standard_D4_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.625,
"burstable": false,
"instanceType": "Standard_D8_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.25,
"burstable": false,
"instanceType": "Standard_D16_v3",
"memory": 64.1,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.5,
"burstable": false,
"instanceType": "Standard_D32_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.0,
"burstable": false,
"instanceType": "Standard_D64_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.15625,
"burstable": false,
"instanceType": "Standard_D2s_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.3125,
"burstable": false,
"instanceType": "Standard_D4s_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.625,
"burstable": false,
"instanceType": "Standard_D8s_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.25,
"burstable": false,
"instanceType": "Standard_D16s_v3",
"memory": 64.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.5,
"burstable": false,
"instanceType": "Standard_D32s_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.0,
"burstable": false,
"instanceType": "Standard_D64s_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.2,
"burstable": false,
"instanceType": "Standard_E2_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.39875,
"burstable": false,
"instanceType": "Standard_E4_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.7975,
"burstable": false,
"instanceType": "Standard_E8_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.59625,
"burstable": false,
"instanceType": "Standard_E16_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.1925,
"burstable": false,
"instanceType": "Standard_E32_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.434,
"burstable": false,
"instanceType": "Standard_E64_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.2,
"burstable": false,
"instanceType": "Standard_E2s_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.39875,
"burstable": false,
"instanceType": "Standard_E4s_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.7975,
"burstable": false,
"instanceType": "Standard_E8s_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.59625,
"burstable": false,
"instanceType": "Standard_E16s_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.1925,
"burstable": false,
"instanceType": "Standard_E32s_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.434,
"burstable": false,
"instanceType": "Standard_E64s_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.03,
"burstable": false,
"instanceType": "Standard_A0",
"memory": 0.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.04,
"burstable": false,
"instanceType": "Standard_A1",
"memory": 1.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.1775,
"burstable": false,
"instanceType": "Standard_A2",
"memory": 3.5,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.355,
"burstable": false,
"instanceType": "Standard_A3",
"memory": 7.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.3475,
"burstable": false,
"instanceType": "Standard_A5",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.58,
"burstable": false,
"instanceType": "Standard_A4",
"memory": 14.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.695,
"burstable": false,
"instanceType": "Standard_A6",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.39,
"burstable": false,
"instanceType": "Standard_A7",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.493,
"burstable": false,
"instanceType": "Standard_D15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.139,
"burstable": false,
"instanceType": "Standard_F2s_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.277,
"burstable": false,
"instanceType": "Standard_F4s_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.554,
"burstable": false,
"instanceType": "Standard_F8s_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.108,
"burstable": false,
"instanceType": "Standard_F16s_v2",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.217,
"burstable": false,
"instanceType": "Standard_F32s_v2",
"memory": 64.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.434,
"burstable": false,
"instanceType": "Standard_F64s_v2",
"memory": 128.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.988,
"burstable": false,
"instanceType": "Standard_F72s_v2",
"memory": 144.0,
"cpu": 72
}
],
"Canada East": [
{
"baseline": 0.2,
"generation": "current",
"price": 0.0233,
"burstable": true,
"instanceType": "Standard_B1ms",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 0.1,
"generation": "current",
"price": 0.013,
"burstable": true,
"instanceType": "Standard_B1s",
"memory": 1.0,
"cpu": 1
},
{
"baseline": 0.6,
"generation": "current",
"price": 0.0932,
"burstable": true,
"instanceType": "Standard_B2ms",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 0.4,
"generation": "current",
"price": 0.0466,
"burstable": true,
"instanceType": "Standard_B2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 0.9,
"generation": "current",
"price": 0.186,
"burstable": true,
"instanceType": "Standard_B4ms",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.35,
"generation": "current",
"price": 0.373,
"burstable": true,
"instanceType": "Standard_B8ms",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.07,
"burstable": false,
"instanceType": "Standard_D1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.14,
"burstable": false,
"instanceType": "Standard_D2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.28,
"burstable": false,
"instanceType": "Standard_D3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.56,
"burstable": false,
"instanceType": "Standard_D4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.12,
"burstable": false,
"instanceType": "Standard_D5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.183,
"burstable": false,
"instanceType": "Standard_D11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.366,
"burstable": false,
"instanceType": "Standard_D12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.732,
"burstable": false,
"instanceType": "Standard_D13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.463,
"burstable": false,
"instanceType": "Standard_D14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.14,
"burstable": false,
"instanceType": "Standard_D2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.28,
"burstable": false,
"instanceType": "Standard_D3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.56,
"burstable": false,
"instanceType": "Standard_D4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.12,
"burstable": false,
"instanceType": "Standard_D5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.183,
"burstable": false,
"instanceType": "Standard_D11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.366,
"burstable": false,
"instanceType": "Standard_D12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.732,
"burstable": false,
"instanceType": "Standard_D13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.463,
"burstable": false,
"instanceType": "Standard_D14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.055,
"burstable": false,
"instanceType": "Standard_F1",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.109,
"burstable": false,
"instanceType": "Standard_F2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.218,
"burstable": false,
"instanceType": "Standard_F4",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.437,
"burstable": false,
"instanceType": "Standard_F8",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.874,
"burstable": false,
"instanceType": "Standard_F16",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.07,
"burstable": false,
"instanceType": "Standard_DS1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.14,
"burstable": false,
"instanceType": "Standard_DS2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.28,
"burstable": false,
"instanceType": "Standard_DS3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.56,
"burstable": false,
"instanceType": "Standard_DS4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.12,
"burstable": false,
"instanceType": "Standard_DS5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.183,
"burstable": false,
"instanceType": "Standard_DS11-1_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.183,
"burstable": false,
"instanceType": "Standard_DS11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.366,
"burstable": false,
"instanceType": "Standard_DS12-1_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.366,
"burstable": false,
"instanceType": "Standard_DS12-2_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.366,
"burstable": false,
"instanceType": "Standard_DS12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.732,
"burstable": false,
"instanceType": "Standard_DS13-2_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.732,
"burstable": false,
"instanceType": "Standard_DS13-4_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.732,
"burstable": false,
"instanceType": "Standard_DS13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.463,
"burstable": false,
"instanceType": "Standard_DS14-4_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.463,
"burstable": false,
"instanceType": "Standard_DS14-8_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.463,
"burstable": false,
"instanceType": "Standard_DS14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.14,
"burstable": false,
"instanceType": "Standard_DS2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.28,
"burstable": false,
"instanceType": "Standard_DS3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.56,
"burstable": false,
"instanceType": "Standard_DS4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.12,
"burstable": false,
"instanceType": "Standard_DS5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.183,
"burstable": false,
"instanceType": "Standard_DS11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.366,
"burstable": false,
"instanceType": "Standard_DS12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.732,
"burstable": false,
"instanceType": "Standard_DS13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.463,
"burstable": false,
"instanceType": "Standard_DS14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.055,
"burstable": false,
"instanceType": "Standard_F1s",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.109,
"burstable": false,
"instanceType": "Standard_F2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.218,
"burstable": false,
"instanceType": "Standard_F4s",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.437,
"burstable": false,
"instanceType": "Standard_F8s",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.874,
"burstable": false,
"instanceType": "Standard_F16s",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.043,
"burstable": false,
"instanceType": "Standard_A1_v2",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.129,
"burstable": false,
"instanceType": "Standard_A2m_v2",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.091,
"burstable": false,
"instanceType": "Standard_A2_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.27,
"burstable": false,
"instanceType": "Standard_A4m_v2",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.191,
"burstable": false,
"instanceType": "Standard_A4_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.568,
"burstable": false,
"instanceType": "Standard_A8m_v2",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.4,
"burstable": false,
"instanceType": "Standard_A8_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.111,
"burstable": false,
"instanceType": "Standard_D2_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.222,
"burstable": false,
"instanceType": "Standard_D4_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.444,
"burstable": false,
"instanceType": "Standard_D8_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.888,
"burstable": false,
"instanceType": "Standard_D16_v3",
"memory": 64.1,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.776,
"burstable": false,
"instanceType": "Standard_D32_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.552,
"burstable": false,
"instanceType": "Standard_D64_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.111,
"burstable": false,
"instanceType": "Standard_D2s_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.222,
"burstable": false,
"instanceType": "Standard_D4s_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.444,
"burstable": false,
"instanceType": "Standard_D8s_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.888,
"burstable": false,
"instanceType": "Standard_D16s_v3",
"memory": 64.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.776,
"burstable": false,
"instanceType": "Standard_D32s_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.552,
"burstable": false,
"instanceType": "Standard_D64s_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.146,
"burstable": false,
"instanceType": "Standard_E2_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.292,
"burstable": false,
"instanceType": "Standard_E4_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.584,
"burstable": false,
"instanceType": "Standard_E8_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.168,
"burstable": false,
"instanceType": "Standard_E16_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.46,
"burstable": false,
"instanceType": "Standard_E20_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.336,
"burstable": false,
"instanceType": "Standard_E32_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.974,
"burstable": false,
"instanceType": "Standard_E64i_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.974,
"burstable": false,
"instanceType": "Standard_E64_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.146,
"burstable": false,
"instanceType": "Standard_E2s_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.292,
"burstable": false,
"instanceType": "Standard_E4s_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.584,
"burstable": false,
"instanceType": "Standard_E8s_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.168,
"burstable": false,
"instanceType": "Standard_E16s_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.46,
"burstable": false,
"instanceType": "Standard_E20s_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.336,
"burstable": false,
"instanceType": "Standard_E32s_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.974,
"burstable": false,
"instanceType": "Standard_E64is_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.974,
"burstable": false,
"instanceType": "Standard_E64s_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.02,
"burstable": false,
"instanceType": "Standard_A0",
"memory": 0.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.026,
"burstable": false,
"instanceType": "Standard_A1",
"memory": 1.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.087,
"burstable": false,
"instanceType": "Standard_A2",
"memory": 3.5,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.194,
"burstable": false,
"instanceType": "Standard_A3",
"memory": 7.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.242,
"burstable": false,
"instanceType": "Standard_A5",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.446,
"burstable": false,
"instanceType": "Standard_A4",
"memory": 14.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.484,
"burstable": false,
"instanceType": "Standard_A6",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.968,
"burstable": false,
"instanceType": "Standard_A7",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.829,
"burstable": false,
"instanceType": "Standard_D15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.69015,
"burstable": false,
"instanceType": "Standard_M8ms",
"memory": 218.75,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.3803,
"burstable": false,
"instanceType": "Standard_M16ms",
"memory": 437.5,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.1603,
"burstable": false,
"instanceType": "Standard_M32ls",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 6.7606,
"burstable": false,
"instanceType": "Standard_M32ms",
"memory": 875.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.9777,
"burstable": false,
"instanceType": "Standard_M32ts",
"memory": 192.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.9565,
"burstable": false,
"instanceType": "Standard_M64ls",
"memory": 512.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 11.3707,
"burstable": false,
"instanceType": "Standard_M64ms",
"memory": 1750.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 7.3359,
"burstable": false,
"instanceType": "Standard_M64s",
"memory": 1000.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 29.3568,
"burstable": false,
"instanceType": "Standard_M128ms",
"memory": 3800.0,
"cpu": 128
},
{
"baseline": 1.0,
"generation": "current",
"price": 14.6718,
"burstable": false,
"instanceType": "Standard_M128s",
"memory": 2000.0,
"cpu": 128
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.0927,
"burstable": false,
"instanceType": "Standard_F2s_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.185,
"burstable": false,
"instanceType": "Standard_F4s_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.371,
"burstable": false,
"instanceType": "Standard_F8s_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.741,
"burstable": false,
"instanceType": "Standard_F16s_v2",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.482,
"burstable": false,
"instanceType": "Standard_F32s_v2",
"memory": 64.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.965,
"burstable": false,
"instanceType": "Standard_F64s_v2",
"memory": 128.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.335,
"burstable": false,
"instanceType": "Standard_F72s_v2",
"memory": 144.0,
"cpu": 72
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.829,
"burstable": false,
"instanceType": "Standard_DS15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.484,
"burstable": false,
"instanceType": "Standard_G1",
"memory": 28.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.968,
"burstable": false,
"instanceType": "Standard_G2",
"memory": 56.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.936,
"burstable": false,
"instanceType": "Standard_G3",
"memory": 112.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.872,
"burstable": false,
"instanceType": "Standard_G4",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 7.744,
"burstable": false,
"instanceType": "Standard_G5",
"memory": 448.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.484,
"burstable": false,
"instanceType": "Standard_GS1",
"memory": 28.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.968,
"burstable": false,
"instanceType": "Standard_GS2",
"memory": 56.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.936,
"burstable": false,
"instanceType": "Standard_GS3",
"memory": 112.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.872,
"burstable": false,
"instanceType": "Standard_GS4",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.872,
"burstable": false,
"instanceType": "Standard_GS4-4",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.872,
"burstable": false,
"instanceType": "Standard_GS4-8",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 7.744,
"burstable": false,
"instanceType": "Standard_GS5",
"memory": 448.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 7.744,
"burstable": false,
"instanceType": "Standard_GS5-8",
"memory": 448.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 7.744,
"burstable": false,
"instanceType": "Standard_GS5-16",
"memory": 448.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.344,
"burstable": false,
"instanceType": "Standard_L4s",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.688,
"burstable": false,
"instanceType": "Standard_L8s",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.376,
"burstable": false,
"instanceType": "Standard_L16s",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.752,
"burstable": false,
"instanceType": "Standard_L32s",
"memory": 256.0,
"cpu": 32
}
],
"West India": [
{
"baseline": 1.0,
"generation": "current",
"price": 0.02,
"burstable": false,
"instanceType": "Standard_A0",
"memory": 0.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.066,
"burstable": false,
"instanceType": "Standard_A1",
"memory": 1.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.096,
"burstable": false,
"instanceType": "Standard_A2",
"memory": 3.5,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.232,
"burstable": false,
"instanceType": "Standard_A3",
"memory": 7.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.26,
"burstable": false,
"instanceType": "Standard_A5",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.464,
"burstable": false,
"instanceType": "Standard_A4",
"memory": 14.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.52,
"burstable": false,
"instanceType": "Standard_A6",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.04,
"burstable": false,
"instanceType": "Standard_A7",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.084,
"burstable": false,
"instanceType": "Standard_D1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.169,
"burstable": false,
"instanceType": "Standard_D2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.337,
"burstable": false,
"instanceType": "Standard_D3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.675,
"burstable": false,
"instanceType": "Standard_D4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.35,
"burstable": false,
"instanceType": "Standard_D5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.189,
"burstable": false,
"instanceType": "Standard_D11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.379,
"burstable": false,
"instanceType": "Standard_D12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.758,
"burstable": false,
"instanceType": "Standard_D13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.516,
"burstable": false,
"instanceType": "Standard_D14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.895,
"burstable": false,
"instanceType": "Standard_D15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.169,
"burstable": false,
"instanceType": "Standard_D2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.337,
"burstable": false,
"instanceType": "Standard_D3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.675,
"burstable": false,
"instanceType": "Standard_D4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.35,
"burstable": false,
"instanceType": "Standard_D5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.189,
"burstable": false,
"instanceType": "Standard_D11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.379,
"burstable": false,
"instanceType": "Standard_D12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.758,
"burstable": false,
"instanceType": "Standard_D13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.516,
"burstable": false,
"instanceType": "Standard_D14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.055,
"burstable": false,
"instanceType": "Standard_F1",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.11,
"burstable": false,
"instanceType": "Standard_F2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.219,
"burstable": false,
"instanceType": "Standard_F4",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.439,
"burstable": false,
"instanceType": "Standard_F8",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.878,
"burstable": false,
"instanceType": "Standard_F16",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.047,
"burstable": false,
"instanceType": "Standard_A1_v2",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.158,
"burstable": false,
"instanceType": "Standard_A2m_v2",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.098,
"burstable": false,
"instanceType": "Standard_A2_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.333,
"burstable": false,
"instanceType": "Standard_A4m_v2",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.206,
"burstable": false,
"instanceType": "Standard_A4_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.699,
"burstable": false,
"instanceType": "Standard_A8m_v2",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.433,
"burstable": false,
"instanceType": "Standard_A8_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.084,
"burstable": false,
"instanceType": "Standard_DS1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.169,
"burstable": false,
"instanceType": "Standard_DS2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.337,
"burstable": false,
"instanceType": "Standard_DS3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.675,
"burstable": false,
"instanceType": "Standard_DS4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.35,
"burstable": false,
"instanceType": "Standard_DS5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.189,
"burstable": false,
"instanceType": "Standard_DS11-1_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.189,
"burstable": false,
"instanceType": "Standard_DS11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.379,
"burstable": false,
"instanceType": "Standard_DS12-1_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.379,
"burstable": false,
"instanceType": "Standard_DS12-2_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.379,
"burstable": false,
"instanceType": "Standard_DS12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.758,
"burstable": false,
"instanceType": "Standard_DS13-2_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.758,
"burstable": false,
"instanceType": "Standard_DS13-4_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.758,
"burstable": false,
"instanceType": "Standard_DS13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.516,
"burstable": false,
"instanceType": "Standard_DS14-4_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.516,
"burstable": false,
"instanceType": "Standard_DS14-8_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.516,
"burstable": false,
"instanceType": "Standard_DS14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.895,
"burstable": false,
"instanceType": "Standard_DS15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.169,
"burstable": false,
"instanceType": "Standard_DS2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.337,
"burstable": false,
"instanceType": "Standard_DS3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.675,
"burstable": false,
"instanceType": "Standard_DS4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.35,
"burstable": false,
"instanceType": "Standard_DS5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.189,
"burstable": false,
"instanceType": "Standard_DS11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.379,
"burstable": false,
"instanceType": "Standard_DS12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.758,
"burstable": false,
"instanceType": "Standard_DS13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.516,
"burstable": false,
"instanceType": "Standard_DS14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.055,
"burstable": false,
"instanceType": "Standard_F1s",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.11,
"burstable": false,
"instanceType": "Standard_F2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.219,
"burstable": false,
"instanceType": "Standard_F4s",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.439,
"burstable": false,
"instanceType": "Standard_F8s",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.878,
"burstable": false,
"instanceType": "Standard_F16s",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 0.2,
"generation": "current",
"price": 0.03,
"burstable": true,
"instanceType": "Standard_B1ms",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 0.1,
"generation": "current",
"price": 0.0147,
"burstable": true,
"instanceType": "Standard_B1s",
"memory": 1.0,
"cpu": 1
},
{
"baseline": 0.6,
"generation": "current",
"price": 0.119,
"burstable": true,
"instanceType": "Standard_B2ms",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 0.4,
"generation": "current",
"price": 0.059,
"burstable": true,
"instanceType": "Standard_B2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 0.9,
"generation": "current",
"price": 0.238,
"burstable": true,
"instanceType": "Standard_B4ms",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.35,
"generation": "current",
"price": 0.476,
"burstable": true,
"instanceType": "Standard_B8ms",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.123,
"burstable": false,
"instanceType": "Standard_D2_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.246,
"burstable": false,
"instanceType": "Standard_D4_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.492,
"burstable": false,
"instanceType": "Standard_D8_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.968,
"burstable": false,
"instanceType": "Standard_D32_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.936,
"burstable": false,
"instanceType": "Standard_D64_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.123,
"burstable": false,
"instanceType": "Standard_D2s_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.246,
"burstable": false,
"instanceType": "Standard_D4s_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.492,
"burstable": false,
"instanceType": "Standard_D8s_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.968,
"burstable": false,
"instanceType": "Standard_D32s_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.936,
"burstable": false,
"instanceType": "Standard_D64s_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.152,
"burstable": false,
"instanceType": "Standard_E2_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.52,
"burstable": false,
"instanceType": "Standard_E20_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.432,
"burstable": false,
"instanceType": "Standard_E32_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.368,
"burstable": false,
"instanceType": "Standard_E64i_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.368,
"burstable": false,
"instanceType": "Standard_E64_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.152,
"burstable": false,
"instanceType": "Standard_E2s_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.52,
"burstable": false,
"instanceType": "Standard_E20s_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.432,
"burstable": false,
"instanceType": "Standard_E32s_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.368,
"burstable": false,
"instanceType": "Standard_E64is_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.368,
"burstable": false,
"instanceType": "Standard_E64s_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.085,
"burstable": false,
"instanceType": "Standard_F2s_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.17,
"burstable": false,
"instanceType": "Standard_F4s_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.34,
"burstable": false,
"instanceType": "Standard_F8s_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.68,
"burstable": false,
"instanceType": "Standard_F16s_v2",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.36,
"burstable": false,
"instanceType": "Standard_F32s_v2",
"memory": 64.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.72,
"burstable": false,
"instanceType": "Standard_F64s_v2",
"memory": 128.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.06,
"burstable": false,
"instanceType": "Standard_F72s_v2",
"memory": 144.0,
"cpu": 72
}
],
"France South": [
{
"baseline": 0.2,
"generation": "current",
"price": 0.0338,
"burstable": true,
"instanceType": "Standard_B1ms",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 0.1,
"generation": "current",
"price": 0.0169,
"burstable": true,
"instanceType": "Standard_B1s",
"memory": 1.0,
"cpu": 1
},
{
"baseline": 0.6,
"generation": "current",
"price": 0.135,
"burstable": true,
"instanceType": "Standard_B2ms",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 0.4,
"generation": "current",
"price": 0.0676,
"burstable": true,
"instanceType": "Standard_B2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 0.9,
"generation": "current",
"price": 0.27,
"burstable": true,
"instanceType": "Standard_B4ms",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.35,
"generation": "current",
"price": 0.541,
"burstable": true,
"instanceType": "Standard_B8ms",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.114,
"burstable": false,
"instanceType": "Standard_D1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.228,
"burstable": false,
"instanceType": "Standard_D2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.456,
"burstable": false,
"instanceType": "Standard_D3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.912,
"burstable": false,
"instanceType": "Standard_D4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.824,
"burstable": false,
"instanceType": "Standard_D5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.304,
"burstable": false,
"instanceType": "Standard_D11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.608,
"burstable": false,
"instanceType": "Standard_D12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.217,
"burstable": false,
"instanceType": "Standard_D13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.434,
"burstable": false,
"instanceType": "Standard_D14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.228,
"burstable": false,
"instanceType": "Standard_D2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.456,
"burstable": false,
"instanceType": "Standard_D3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.912,
"burstable": false,
"instanceType": "Standard_D4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.824,
"burstable": false,
"instanceType": "Standard_D5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.304,
"burstable": false,
"instanceType": "Standard_D11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.608,
"burstable": false,
"instanceType": "Standard_D12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.217,
"burstable": false,
"instanceType": "Standard_D13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.434,
"burstable": false,
"instanceType": "Standard_D14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.066,
"burstable": false,
"instanceType": "Standard_F1",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.131,
"burstable": false,
"instanceType": "Standard_F2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.262,
"burstable": false,
"instanceType": "Standard_F4",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.525,
"burstable": false,
"instanceType": "Standard_F8",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.05,
"burstable": false,
"instanceType": "Standard_F16",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.114,
"burstable": false,
"instanceType": "Standard_DS1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.228,
"burstable": false,
"instanceType": "Standard_DS2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.456,
"burstable": false,
"instanceType": "Standard_DS3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.912,
"burstable": false,
"instanceType": "Standard_DS4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.824,
"burstable": false,
"instanceType": "Standard_DS5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.304,
"burstable": false,
"instanceType": "Standard_DS11-1_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.304,
"burstable": false,
"instanceType": "Standard_DS11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.608,
"burstable": false,
"instanceType": "Standard_DS12-1_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.608,
"burstable": false,
"instanceType": "Standard_DS12-2_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.608,
"burstable": false,
"instanceType": "Standard_DS12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.217,
"burstable": false,
"instanceType": "Standard_DS13-2_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.217,
"burstable": false,
"instanceType": "Standard_DS13-4_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.217,
"burstable": false,
"instanceType": "Standard_DS13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.434,
"burstable": false,
"instanceType": "Standard_DS14-4_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.434,
"burstable": false,
"instanceType": "Standard_DS14-8_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.434,
"burstable": false,
"instanceType": "Standard_DS14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.228,
"burstable": false,
"instanceType": "Standard_DS2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.456,
"burstable": false,
"instanceType": "Standard_DS3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.912,
"burstable": false,
"instanceType": "Standard_DS4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.824,
"burstable": false,
"instanceType": "Standard_DS5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.304,
"burstable": false,
"instanceType": "Standard_DS11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.608,
"burstable": false,
"instanceType": "Standard_DS12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.217,
"burstable": false,
"instanceType": "Standard_DS13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.434,
"burstable": false,
"instanceType": "Standard_DS14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.066,
"burstable": false,
"instanceType": "Standard_F1s",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.131,
"burstable": false,
"instanceType": "Standard_F2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.262,
"burstable": false,
"instanceType": "Standard_F4s",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.525,
"burstable": false,
"instanceType": "Standard_F8s",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.05,
"burstable": false,
"instanceType": "Standard_F16s",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.065,
"burstable": false,
"instanceType": "Standard_A1_v2",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.2314,
"burstable": false,
"instanceType": "Standard_A2m_v2",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.1378,
"burstable": false,
"instanceType": "Standard_A2_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.4862,
"burstable": false,
"instanceType": "Standard_A4m_v2",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.2886,
"burstable": false,
"instanceType": "Standard_A4_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.0218,
"burstable": false,
"instanceType": "Standard_A8m_v2",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.6071,
"burstable": false,
"instanceType": "Standard_A8_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.1456,
"burstable": false,
"instanceType": "Standard_D2_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.291,
"burstable": false,
"instanceType": "Standard_D4_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.582,
"burstable": false,
"instanceType": "Standard_D8_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.1648,
"burstable": false,
"instanceType": "Standard_D16_v3",
"memory": 64.1,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.3296,
"burstable": false,
"instanceType": "Standard_D32_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.6592,
"burstable": false,
"instanceType": "Standard_D64_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.1456,
"burstable": false,
"instanceType": "Standard_D2s_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.291,
"burstable": false,
"instanceType": "Standard_D4s_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.582,
"burstable": false,
"instanceType": "Standard_D8s_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.1648,
"burstable": false,
"instanceType": "Standard_D16s_v3",
"memory": 64.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.3296,
"burstable": false,
"instanceType": "Standard_D32s_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.6592,
"burstable": false,
"instanceType": "Standard_D64s_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.2028,
"burstable": false,
"instanceType": "Standard_E2_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.4056,
"burstable": false,
"instanceType": "Standard_E4_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.8112,
"burstable": false,
"instanceType": "Standard_E8_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.6224,
"burstable": false,
"instanceType": "Standard_E16_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.2448,
"burstable": false,
"instanceType": "Standard_E32_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.835,
"burstable": false,
"instanceType": "Standard_E64i_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.835,
"burstable": false,
"instanceType": "Standard_E64_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.2028,
"burstable": false,
"instanceType": "Standard_E2s_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.4056,
"burstable": false,
"instanceType": "Standard_E4s_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.8112,
"burstable": false,
"instanceType": "Standard_E8s_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.6224,
"burstable": false,
"instanceType": "Standard_E16s_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.2448,
"burstable": false,
"instanceType": "Standard_E32s_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.835,
"burstable": false,
"instanceType": "Standard_E64is_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.835,
"burstable": false,
"instanceType": "Standard_E64s_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.026,
"burstable": false,
"instanceType": "Standard_A0",
"memory": 0.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.0338,
"burstable": false,
"instanceType": "Standard_A1",
"memory": 1.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.1313,
"burstable": false,
"instanceType": "Standard_A2",
"memory": 3.5,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.3432,
"burstable": false,
"instanceType": "Standard_A3",
"memory": 7.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.3861,
"burstable": false,
"instanceType": "Standard_A5",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.5837,
"burstable": false,
"instanceType": "Standard_A4",
"memory": 14.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.7722,
"burstable": false,
"instanceType": "Standard_A6",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.5444,
"burstable": false,
"instanceType": "Standard_A7",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.042,
"burstable": false,
"instanceType": "Standard_D15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.131,
"burstable": false,
"instanceType": "Standard_F2s_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.262,
"burstable": false,
"instanceType": "Standard_F4s_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.524,
"burstable": false,
"instanceType": "Standard_F8s_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.047,
"burstable": false,
"instanceType": "Standard_F16s_v2",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.094,
"burstable": false,
"instanceType": "Standard_F32s_v2",
"memory": 64.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.189,
"burstable": false,
"instanceType": "Standard_F64s_v2",
"memory": 128.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.712,
"burstable": false,
"instanceType": "Standard_F72s_v2",
"memory": 144.0,
"cpu": 72
}
],
"Japan West": [
{
"baseline": 1.0,
"generation": "current",
"price": 0.091,
"burstable": false,
"instanceType": "Standard_D1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.182,
"burstable": false,
"instanceType": "Standard_D2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.365,
"burstable": false,
"instanceType": "Standard_D3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.729,
"burstable": false,
"instanceType": "Standard_D4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.459,
"burstable": false,
"instanceType": "Standard_D5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.2,
"burstable": false,
"instanceType": "Standard_D11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.399,
"burstable": false,
"instanceType": "Standard_D12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.798,
"burstable": false,
"instanceType": "Standard_D13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.596,
"burstable": false,
"instanceType": "Standard_D14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.182,
"burstable": false,
"instanceType": "Standard_D2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.365,
"burstable": false,
"instanceType": "Standard_D3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.729,
"burstable": false,
"instanceType": "Standard_D4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.459,
"burstable": false,
"instanceType": "Standard_D5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.2,
"burstable": false,
"instanceType": "Standard_D11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.399,
"burstable": false,
"instanceType": "Standard_D12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.798,
"burstable": false,
"instanceType": "Standard_D13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.596,
"burstable": false,
"instanceType": "Standard_D14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.063,
"burstable": false,
"instanceType": "Standard_F1",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.126,
"burstable": false,
"instanceType": "Standard_F2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.252,
"burstable": false,
"instanceType": "Standard_F4",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.504,
"burstable": false,
"instanceType": "Standard_F8",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.008,
"burstable": false,
"instanceType": "Standard_F16",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.0171,
"burstable": false,
"instanceType": "Standard_A0",
"memory": 0.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.032,
"burstable": false,
"instanceType": "Standard_A1",
"memory": 1.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.099,
"burstable": false,
"instanceType": "Standard_A2",
"memory": 3.5,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.2196,
"burstable": false,
"instanceType": "Standard_A3",
"memory": 7.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.258,
"burstable": false,
"instanceType": "Standard_A5",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.584,
"burstable": false,
"instanceType": "Standard_A4",
"memory": 14.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.516,
"burstable": false,
"instanceType": "Standard_A6",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.032,
"burstable": false,
"instanceType": "Standard_A7",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.054,
"burstable": false,
"instanceType": "Standard_A1_v2",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.178,
"burstable": false,
"instanceType": "Standard_A2m_v2",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.113,
"burstable": false,
"instanceType": "Standard_A2_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.374,
"burstable": false,
"instanceType": "Standard_A4m_v2",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.238,
"burstable": false,
"instanceType": "Standard_A4_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.786,
"burstable": false,
"instanceType": "Standard_A8m_v2",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.5,
"burstable": false,
"instanceType": "Standard_A8_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.129,
"burstable": false,
"instanceType": "Standard_D2_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.258,
"burstable": false,
"instanceType": "Standard_D4_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.516,
"burstable": false,
"instanceType": "Standard_D8_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.032,
"burstable": false,
"instanceType": "Standard_D16_v3",
"memory": 64.1,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.064,
"burstable": false,
"instanceType": "Standard_D32_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.128,
"burstable": false,
"instanceType": "Standard_D64_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.16,
"burstable": false,
"instanceType": "Standard_E2_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.32,
"burstable": false,
"instanceType": "Standard_E4_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.64,
"burstable": false,
"instanceType": "Standard_E8_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.28,
"burstable": false,
"instanceType": "Standard_E16_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.6,
"burstable": false,
"instanceType": "Standard_E20_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.56,
"burstable": false,
"instanceType": "Standard_E32_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.609,
"burstable": false,
"instanceType": "Standard_E64i_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.609,
"burstable": false,
"instanceType": "Standard_E64_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.091,
"burstable": false,
"instanceType": "Standard_DS1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.182,
"burstable": false,
"instanceType": "Standard_DS2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.365,
"burstable": false,
"instanceType": "Standard_DS3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.729,
"burstable": false,
"instanceType": "Standard_DS4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.459,
"burstable": false,
"instanceType": "Standard_DS5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.2,
"burstable": false,
"instanceType": "Standard_DS11-1_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.2,
"burstable": false,
"instanceType": "Standard_DS11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.399,
"burstable": false,
"instanceType": "Standard_DS12-1_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.399,
"burstable": false,
"instanceType": "Standard_DS12-2_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.399,
"burstable": false,
"instanceType": "Standard_DS12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.798,
"burstable": false,
"instanceType": "Standard_DS13-2_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.798,
"burstable": false,
"instanceType": "Standard_DS13-4_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.798,
"burstable": false,
"instanceType": "Standard_DS13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.596,
"burstable": false,
"instanceType": "Standard_DS14-4_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.596,
"burstable": false,
"instanceType": "Standard_DS14-8_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.596,
"burstable": false,
"instanceType": "Standard_DS14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.995,
"burstable": false,
"instanceType": "Standard_DS15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.182,
"burstable": false,
"instanceType": "Standard_DS2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.365,
"burstable": false,
"instanceType": "Standard_DS3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.729,
"burstable": false,
"instanceType": "Standard_DS4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.459,
"burstable": false,
"instanceType": "Standard_DS5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.2,
"burstable": false,
"instanceType": "Standard_DS11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.399,
"burstable": false,
"instanceType": "Standard_DS12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.798,
"burstable": false,
"instanceType": "Standard_DS13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.596,
"burstable": false,
"instanceType": "Standard_DS14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.096,
"burstable": false,
"instanceType": "Standard_DS1",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.192,
"burstable": false,
"instanceType": "Standard_DS2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.384,
"burstable": false,
"instanceType": "Standard_DS3",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.768,
"burstable": false,
"instanceType": "Standard_DS4",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.21,
"burstable": false,
"instanceType": "Standard_DS11",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.42,
"burstable": false,
"instanceType": "Standard_DS12",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.84,
"burstable": false,
"instanceType": "Standard_DS13",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.68,
"burstable": false,
"instanceType": "Standard_DS14",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.063,
"burstable": false,
"instanceType": "Standard_F1s",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.126,
"burstable": false,
"instanceType": "Standard_F2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.252,
"burstable": false,
"instanceType": "Standard_F4s",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.504,
"burstable": false,
"instanceType": "Standard_F8s",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.008,
"burstable": false,
"instanceType": "Standard_F16s",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.995,
"burstable": false,
"instanceType": "Standard_D15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 0.2,
"generation": "current",
"price": 0.03,
"burstable": true,
"instanceType": "Standard_B1ms",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 0.1,
"generation": "current",
"price": 0.016,
"burstable": true,
"instanceType": "Standard_B1s",
"memory": 1.0,
"cpu": 1
},
{
"baseline": 0.6,
"generation": "current",
"price": 0.12,
"burstable": true,
"instanceType": "Standard_B2ms",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 0.4,
"generation": "current",
"price": 0.0599,
"burstable": true,
"instanceType": "Standard_B2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 0.9,
"generation": "current",
"price": 0.24,
"burstable": true,
"instanceType": "Standard_B4ms",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.35,
"generation": "current",
"price": 0.479,
"burstable": true,
"instanceType": "Standard_B8ms",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.129,
"burstable": false,
"instanceType": "Standard_D2s_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.258,
"burstable": false,
"instanceType": "Standard_D4s_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.516,
"burstable": false,
"instanceType": "Standard_D8s_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.032,
"burstable": false,
"instanceType": "Standard_D16s_v3",
"memory": 64.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.064,
"burstable": false,
"instanceType": "Standard_D32s_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.128,
"burstable": false,
"instanceType": "Standard_D64s_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.16,
"burstable": false,
"instanceType": "Standard_E2s_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.32,
"burstable": false,
"instanceType": "Standard_E4s_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.64,
"burstable": false,
"instanceType": "Standard_E8s_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.28,
"burstable": false,
"instanceType": "Standard_E16s_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.6,
"burstable": false,
"instanceType": "Standard_E20s_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.56,
"burstable": false,
"instanceType": "Standard_E32s_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.609,
"burstable": false,
"instanceType": "Standard_E64is_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.609,
"burstable": false,
"instanceType": "Standard_E64s_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.096,
"burstable": false,
"instanceType": "Standard_D1",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.192,
"burstable": false,
"instanceType": "Standard_D2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.384,
"burstable": false,
"instanceType": "Standard_D3",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.768,
"burstable": false,
"instanceType": "Standard_D4",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.21,
"burstable": false,
"instanceType": "Standard_D11",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.42,
"burstable": false,
"instanceType": "Standard_D12",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.84,
"burstable": false,
"instanceType": "Standard_D13",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.68,
"burstable": false,
"instanceType": "Standard_D14",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.117,
"burstable": false,
"instanceType": "Standard_F2s_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.235,
"burstable": false,
"instanceType": "Standard_F4s_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.469,
"burstable": false,
"instanceType": "Standard_F8s_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.938,
"burstable": false,
"instanceType": "Standard_F16s_v2",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.877,
"burstable": false,
"instanceType": "Standard_F32s_v2",
"memory": 64.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.754,
"burstable": false,
"instanceType": "Standard_F64s_v2",
"memory": 128.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.223,
"burstable": false,
"instanceType": "Standard_F72s_v2",
"memory": 144.0,
"cpu": 72
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.2279,
"burstable": false,
"instanceType": "Standard_M8ms",
"memory": 218.75,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.4559,
"burstable": false,
"instanceType": "Standard_M16ms",
"memory": 437.5,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.4476,
"burstable": false,
"instanceType": "Standard_M32ls",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 8.9117,
"burstable": false,
"instanceType": "Standard_M32ms",
"memory": 875.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.2484,
"burstable": false,
"instanceType": "Standard_M32ts",
"memory": 192.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 6.498,
"burstable": false,
"instanceType": "Standard_M64ls",
"memory": 512.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 14.99,
"burstable": false,
"instanceType": "Standard_M64ms",
"memory": 1750.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 9.671,
"burstable": false,
"instanceType": "Standard_M64s",
"memory": 1000.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 38.701,
"burstable": false,
"instanceType": "Standard_M128ms",
"memory": 3800.0,
"cpu": 128
},
{
"baseline": 1.0,
"generation": "current",
"price": 19.342,
"burstable": false,
"instanceType": "Standard_M128s",
"memory": 2000.0,
"cpu": 128
}
],
"East Asia": [
{
"baseline": 1.0,
"generation": "current",
"price": 0.018,
"burstable": false,
"instanceType": "Standard_A0",
"memory": 0.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.038,
"burstable": false,
"instanceType": "Standard_A1",
"memory": 1.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.12,
"burstable": false,
"instanceType": "Standard_A2",
"memory": 3.5,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.24,
"burstable": false,
"instanceType": "Standard_A3",
"memory": 7.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.294,
"burstable": false,
"instanceType": "Standard_A5",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.48,
"burstable": false,
"instanceType": "Standard_A4",
"memory": 14.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.588,
"burstable": false,
"instanceType": "Standard_A6",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.176,
"burstable": false,
"instanceType": "Standard_A7",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.107,
"burstable": false,
"instanceType": "Standard_D1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.214,
"burstable": false,
"instanceType": "Standard_D2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.428,
"burstable": false,
"instanceType": "Standard_D3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.857,
"burstable": false,
"instanceType": "Standard_D4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.714,
"burstable": false,
"instanceType": "Standard_D5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.229,
"burstable": false,
"instanceType": "Standard_D11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.459,
"burstable": false,
"instanceType": "Standard_D12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.918,
"burstable": false,
"instanceType": "Standard_D13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.835,
"burstable": false,
"instanceType": "Standard_D14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.294,
"burstable": false,
"instanceType": "Standard_D15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.214,
"burstable": false,
"instanceType": "Standard_D2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.428,
"burstable": false,
"instanceType": "Standard_D3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.857,
"burstable": false,
"instanceType": "Standard_D4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.714,
"burstable": false,
"instanceType": "Standard_D5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.229,
"burstable": false,
"instanceType": "Standard_D11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.459,
"burstable": false,
"instanceType": "Standard_D12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.918,
"burstable": false,
"instanceType": "Standard_D13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.835,
"burstable": false,
"instanceType": "Standard_D14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.072,
"burstable": false,
"instanceType": "Standard_F1",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.144,
"burstable": false,
"instanceType": "Standard_F2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.289,
"burstable": false,
"instanceType": "Standard_F4",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.578,
"burstable": false,
"instanceType": "Standard_F8",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.155,
"burstable": false,
"instanceType": "Standard_F16",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.05,
"burstable": false,
"instanceType": "Standard_A1_v2",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.178,
"burstable": false,
"instanceType": "Standard_A2m_v2",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.106,
"burstable": false,
"instanceType": "Standard_A2_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.374,
"burstable": false,
"instanceType": "Standard_A4m_v2",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.222,
"burstable": false,
"instanceType": "Standard_A4_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.786,
"burstable": false,
"instanceType": "Standard_A8m_v2",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.467,
"burstable": false,
"instanceType": "Standard_A8_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.156,
"burstable": false,
"instanceType": "Standard_D2_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.313,
"burstable": false,
"instanceType": "Standard_D4_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.625,
"burstable": false,
"instanceType": "Standard_D8_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.25,
"burstable": false,
"instanceType": "Standard_D16_v3",
"memory": 64.1,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.5,
"burstable": false,
"instanceType": "Standard_D32_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.113,
"burstable": false,
"instanceType": "Standard_DS1",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.225,
"burstable": false,
"instanceType": "Standard_DS2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.451,
"burstable": false,
"instanceType": "Standard_DS3",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.902,
"burstable": false,
"instanceType": "Standard_DS4",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.242,
"burstable": false,
"instanceType": "Standard_DS11",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.483,
"burstable": false,
"instanceType": "Standard_DS12",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.966,
"burstable": false,
"instanceType": "Standard_DS13",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.932,
"burstable": false,
"instanceType": "Standard_DS14",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 0.2,
"generation": "current",
"price": 0.034,
"burstable": true,
"instanceType": "Standard_B1ms",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 0.1,
"generation": "current",
"price": 0.017,
"burstable": true,
"instanceType": "Standard_B1s",
"memory": 1.0,
"cpu": 1
},
{
"baseline": 0.6,
"generation": "current",
"price": 0.135,
"burstable": true,
"instanceType": "Standard_B2ms",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 0.4,
"generation": "current",
"price": 0.068,
"burstable": true,
"instanceType": "Standard_B2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 0.9,
"generation": "current",
"price": 0.27,
"burstable": true,
"instanceType": "Standard_B4ms",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.35,
"generation": "current",
"price": 0.54,
"burstable": true,
"instanceType": "Standard_B8ms",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.107,
"burstable": false,
"instanceType": "Standard_DS1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.214,
"burstable": false,
"instanceType": "Standard_DS2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.428,
"burstable": false,
"instanceType": "Standard_DS3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.857,
"burstable": false,
"instanceType": "Standard_DS4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.714,
"burstable": false,
"instanceType": "Standard_DS5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.229,
"burstable": false,
"instanceType": "Standard_DS11-1_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.229,
"burstable": false,
"instanceType": "Standard_DS11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.459,
"burstable": false,
"instanceType": "Standard_DS12-1_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.459,
"burstable": false,
"instanceType": "Standard_DS12-2_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.459,
"burstable": false,
"instanceType": "Standard_DS12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.918,
"burstable": false,
"instanceType": "Standard_DS13-2_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.918,
"burstable": false,
"instanceType": "Standard_DS13-4_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.918,
"burstable": false,
"instanceType": "Standard_DS13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.835,
"burstable": false,
"instanceType": "Standard_DS14-4_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.835,
"burstable": false,
"instanceType": "Standard_DS14-8_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.835,
"burstable": false,
"instanceType": "Standard_DS14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.294,
"burstable": false,
"instanceType": "Standard_DS15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.214,
"burstable": false,
"instanceType": "Standard_DS2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.428,
"burstable": false,
"instanceType": "Standard_DS3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.857,
"burstable": false,
"instanceType": "Standard_DS4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.714,
"burstable": false,
"instanceType": "Standard_DS5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.229,
"burstable": false,
"instanceType": "Standard_DS11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.459,
"burstable": false,
"instanceType": "Standard_DS12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.918,
"burstable": false,
"instanceType": "Standard_DS13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.835,
"burstable": false,
"instanceType": "Standard_DS14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.072,
"burstable": false,
"instanceType": "Standard_F1s",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.144,
"burstable": false,
"instanceType": "Standard_F2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.289,
"burstable": false,
"instanceType": "Standard_F4s",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.578,
"burstable": false,
"instanceType": "Standard_F8s",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.155,
"burstable": false,
"instanceType": "Standard_F16s",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.156,
"burstable": false,
"instanceType": "Standard_D2s_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.313,
"burstable": false,
"instanceType": "Standard_D4s_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.625,
"burstable": false,
"instanceType": "Standard_D8s_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.25,
"burstable": false,
"instanceType": "Standard_D16s_v3",
"memory": 64.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.5,
"burstable": false,
"instanceType": "Standard_D32s_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.0,
"burstable": false,
"instanceType": "Standard_D64_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.0,
"burstable": false,
"instanceType": "Standard_D64s_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.2,
"burstable": false,
"instanceType": "Standard_E2_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.4,
"burstable": false,
"instanceType": "Standard_E4_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.8,
"burstable": false,
"instanceType": "Standard_E8_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.6,
"burstable": false,
"instanceType": "Standard_E16_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.0,
"burstable": false,
"instanceType": "Standard_E20_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.2,
"burstable": false,
"instanceType": "Standard_E32_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.625,
"burstable": false,
"instanceType": "Standard_E64i_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.625,
"burstable": false,
"instanceType": "Standard_E64_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.2,
"burstable": false,
"instanceType": "Standard_E2s_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.4,
"burstable": false,
"instanceType": "Standard_E4s_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.8,
"burstable": false,
"instanceType": "Standard_E8s_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.6,
"burstable": false,
"instanceType": "Standard_E16s_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.0,
"burstable": false,
"instanceType": "Standard_E20s_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.2,
"burstable": false,
"instanceType": "Standard_E32s_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.625,
"burstable": false,
"instanceType": "Standard_E64is_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.625,
"burstable": false,
"instanceType": "Standard_E64s_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.113,
"burstable": false,
"instanceType": "Standard_D1",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.225,
"burstable": false,
"instanceType": "Standard_D2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.451,
"burstable": false,
"instanceType": "Standard_D3",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.902,
"burstable": false,
"instanceType": "Standard_D4",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.242,
"burstable": false,
"instanceType": "Standard_D11",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.483,
"burstable": false,
"instanceType": "Standard_D12",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.966,
"burstable": false,
"instanceType": "Standard_D13",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.932,
"burstable": false,
"instanceType": "Standard_D14",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.784875,
"burstable": false,
"instanceType": "Standard_M8ms",
"memory": 218.75,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.569875,
"burstable": false,
"instanceType": "Standard_M16ms",
"memory": 437.5,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.3095,
"burstable": false,
"instanceType": "Standard_M32ls",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 11.139625,
"burstable": false,
"instanceType": "Standard_M32ms",
"memory": 875.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.0605,
"burstable": false,
"instanceType": "Standard_M32ts",
"memory": 192.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 8.1225,
"burstable": false,
"instanceType": "Standard_M64ls",
"memory": 512.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 18.7375,
"burstable": false,
"instanceType": "Standard_M64ms",
"memory": 1750.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 12.08875,
"burstable": false,
"instanceType": "Standard_M64s",
"memory": 1000.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 48.37625,
"burstable": false,
"instanceType": "Standard_M128ms",
"memory": 3800.0,
"cpu": 128
},
{
"baseline": 1.0,
"generation": "current",
"price": 24.1775,
"burstable": false,
"instanceType": "Standard_M128s",
"memory": 2000.0,
"cpu": 128
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.122,
"burstable": false,
"instanceType": "Standard_F2s_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.245,
"burstable": false,
"instanceType": "Standard_F4s_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.49,
"burstable": false,
"instanceType": "Standard_F8s_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.979,
"burstable": false,
"instanceType": "Standard_F16s_v2",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.958,
"burstable": false,
"instanceType": "Standard_F32s_v2",
"memory": 64.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.917,
"burstable": false,
"instanceType": "Standard_F64s_v2",
"memory": 128.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.406,
"burstable": false,
"instanceType": "Standard_F72s_v2",
"memory": 144.0,
"cpu": 72
}
],
"Southeast Asia": [
{
"baseline": 1.0,
"generation": "current",
"price": 1.59,
"burstable": false,
"instanceType": "Standard_NV6",
"memory": 56.0,
"cpu": 6
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.18,
"burstable": false,
"instanceType": "Standard_NV12",
"memory": 112.0,
"cpu": 12
},
{
"baseline": 1.0,
"generation": "current",
"price": 6.36,
"burstable": false,
"instanceType": "Standard_NV24",
"memory": 224.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.018,
"burstable": false,
"instanceType": "Standard_A0",
"memory": 0.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.06,
"burstable": false,
"instanceType": "Standard_A1",
"memory": 1.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.095,
"burstable": false,
"instanceType": "Standard_A2",
"memory": 3.5,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.232,
"burstable": false,
"instanceType": "Standard_A3",
"memory": 7.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.27,
"burstable": false,
"instanceType": "Standard_A5",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.48,
"burstable": false,
"instanceType": "Standard_A4",
"memory": 14.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.54,
"burstable": false,
"instanceType": "Standard_A6",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.08,
"burstable": false,
"instanceType": "Standard_A7",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.079,
"burstable": false,
"instanceType": "Standard_D1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.158,
"burstable": false,
"instanceType": "Standard_D2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.316,
"burstable": false,
"instanceType": "Standard_D3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.631,
"burstable": false,
"instanceType": "Standard_D4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.263,
"burstable": false,
"instanceType": "Standard_D5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.191,
"burstable": false,
"instanceType": "Standard_D11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.382,
"burstable": false,
"instanceType": "Standard_D12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.765,
"burstable": false,
"instanceType": "Standard_D13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.53,
"burstable": false,
"instanceType": "Standard_D14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.912,
"burstable": false,
"instanceType": "Standard_D15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.158,
"burstable": false,
"instanceType": "Standard_D2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.316,
"burstable": false,
"instanceType": "Standard_D3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.631,
"burstable": false,
"instanceType": "Standard_D4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.263,
"burstable": false,
"instanceType": "Standard_D5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.191,
"burstable": false,
"instanceType": "Standard_D11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.382,
"burstable": false,
"instanceType": "Standard_D12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.765,
"burstable": false,
"instanceType": "Standard_D13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.53,
"burstable": false,
"instanceType": "Standard_D14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.058,
"burstable": false,
"instanceType": "Standard_F1",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.115,
"burstable": false,
"instanceType": "Standard_F2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.231,
"burstable": false,
"instanceType": "Standard_F4",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.462,
"burstable": false,
"instanceType": "Standard_F8",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.924,
"burstable": false,
"instanceType": "Standard_F16",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.045,
"burstable": false,
"instanceType": "Standard_A1_v2",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.134,
"burstable": false,
"instanceType": "Standard_A2m_v2",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.095,
"burstable": false,
"instanceType": "Standard_A2_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.281,
"burstable": false,
"instanceType": "Standard_A4m_v2",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.198,
"burstable": false,
"instanceType": "Standard_A4_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.589,
"burstable": false,
"instanceType": "Standard_A8m_v2",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.417,
"burstable": false,
"instanceType": "Standard_A8_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.125,
"burstable": false,
"instanceType": "Standard_D2_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.25,
"burstable": false,
"instanceType": "Standard_D4_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.5,
"burstable": false,
"instanceType": "Standard_D8_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.0,
"burstable": false,
"instanceType": "Standard_D16_v3",
"memory": 64.1,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.0,
"burstable": false,
"instanceType": "Standard_D32_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.098,
"burstable": false,
"instanceType": "Standard_D1",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.196,
"burstable": false,
"instanceType": "Standard_D2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.392,
"burstable": false,
"instanceType": "Standard_D3",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.784,
"burstable": false,
"instanceType": "Standard_D4",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.21,
"burstable": false,
"instanceType": "Standard_D11",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.42,
"burstable": false,
"instanceType": "Standard_D12",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.84,
"burstable": false,
"instanceType": "Standard_D13",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.68,
"burstable": false,
"instanceType": "Standard_D14",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 0.2,
"generation": "current",
"price": 0.0264,
"burstable": true,
"instanceType": "Standard_B1ms",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 0.1,
"generation": "current",
"price": 0.0132,
"burstable": true,
"instanceType": "Standard_B1s",
"memory": 1.0,
"cpu": 1
},
{
"baseline": 0.6,
"generation": "current",
"price": 0.106,
"burstable": true,
"instanceType": "Standard_B2ms",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 0.4,
"generation": "current",
"price": 0.0528,
"burstable": true,
"instanceType": "Standard_B2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 0.9,
"generation": "current",
"price": 0.211,
"burstable": true,
"instanceType": "Standard_B4ms",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.35,
"generation": "current",
"price": 0.422,
"burstable": true,
"instanceType": "Standard_B8ms",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.079,
"burstable": false,
"instanceType": "Standard_DS1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.158,
"burstable": false,
"instanceType": "Standard_DS2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.316,
"burstable": false,
"instanceType": "Standard_DS3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.631,
"burstable": false,
"instanceType": "Standard_DS4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.263,
"burstable": false,
"instanceType": "Standard_DS5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.191,
"burstable": false,
"instanceType": "Standard_DS11-1_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.191,
"burstable": false,
"instanceType": "Standard_DS11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.382,
"burstable": false,
"instanceType": "Standard_DS12-1_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.382,
"burstable": false,
"instanceType": "Standard_DS12-2_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.382,
"burstable": false,
"instanceType": "Standard_DS12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.765,
"burstable": false,
"instanceType": "Standard_DS13-2_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.765,
"burstable": false,
"instanceType": "Standard_DS13-4_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.765,
"burstable": false,
"instanceType": "Standard_DS13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.53,
"burstable": false,
"instanceType": "Standard_DS14-4_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.53,
"burstable": false,
"instanceType": "Standard_DS14-8_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.53,
"burstable": false,
"instanceType": "Standard_DS14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.158,
"burstable": false,
"instanceType": "Standard_DS2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.316,
"burstable": false,
"instanceType": "Standard_DS3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.631,
"burstable": false,
"instanceType": "Standard_DS4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.263,
"burstable": false,
"instanceType": "Standard_DS5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.191,
"burstable": false,
"instanceType": "Standard_DS11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.382,
"burstable": false,
"instanceType": "Standard_DS12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.765,
"burstable": false,
"instanceType": "Standard_DS13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.53,
"burstable": false,
"instanceType": "Standard_DS14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.058,
"burstable": false,
"instanceType": "Standard_F1s",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.115,
"burstable": false,
"instanceType": "Standard_F2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.231,
"burstable": false,
"instanceType": "Standard_F4s",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.462,
"burstable": false,
"instanceType": "Standard_F8s",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.924,
"burstable": false,
"instanceType": "Standard_F16s",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.0,
"burstable": false,
"instanceType": "Standard_D64_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.125,
"burstable": false,
"instanceType": "Standard_D2s_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.25,
"burstable": false,
"instanceType": "Standard_D4s_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.5,
"burstable": false,
"instanceType": "Standard_D8s_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.0,
"burstable": false,
"instanceType": "Standard_D16s_v3",
"memory": 64.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.0,
"burstable": false,
"instanceType": "Standard_D32s_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.0,
"burstable": false,
"instanceType": "Standard_D64s_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.16,
"burstable": false,
"instanceType": "Standard_E2_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.32,
"burstable": false,
"instanceType": "Standard_E4_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.64,
"burstable": false,
"instanceType": "Standard_E8_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.28,
"burstable": false,
"instanceType": "Standard_E16_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.6,
"burstable": false,
"instanceType": "Standard_E20_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.56,
"burstable": false,
"instanceType": "Standard_E32_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.609,
"burstable": false,
"instanceType": "Standard_E64i_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.609,
"burstable": false,
"instanceType": "Standard_E64_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.16,
"burstable": false,
"instanceType": "Standard_E2s_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.32,
"burstable": false,
"instanceType": "Standard_E4s_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.64,
"burstable": false,
"instanceType": "Standard_E8s_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.28,
"burstable": false,
"instanceType": "Standard_E16s_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.6,
"burstable": false,
"instanceType": "Standard_E20s_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.56,
"burstable": false,
"instanceType": "Standard_E32s_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.609,
"burstable": false,
"instanceType": "Standard_E64is_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.609,
"burstable": false,
"instanceType": "Standard_E64s_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.912,
"burstable": false,
"instanceType": "Standard_DS15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.814,
"burstable": false,
"instanceType": "Standard_NC6s_v3",
"memory": 112.0,
"cpu": 6
},
{
"baseline": 1.0,
"generation": "current",
"price": 11.628,
"burstable": false,
"instanceType": "Standard_NC12s_v3",
"memory": 224.0,
"cpu": 12
},
{
"baseline": 1.0,
"generation": "current",
"price": 25.5816,
"burstable": false,
"instanceType": "Standard_NC24rs_v3",
"memory": 448.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 23.256,
"burstable": false,
"instanceType": "Standard_NC24s_v3",
"memory": 448.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.098,
"burstable": false,
"instanceType": "Standard_DS1",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.196,
"burstable": false,
"instanceType": "Standard_DS2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.392,
"burstable": false,
"instanceType": "Standard_DS3",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.784,
"burstable": false,
"instanceType": "Standard_DS4",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.21,
"burstable": false,
"instanceType": "Standard_DS11",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.42,
"burstable": false,
"instanceType": "Standard_DS12",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.84,
"burstable": false,
"instanceType": "Standard_DS13",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.68,
"burstable": false,
"instanceType": "Standard_DS14",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.2279,
"burstable": false,
"instanceType": "Standard_M8ms",
"memory": 218.75,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.4559,
"burstable": false,
"instanceType": "Standard_M16ms",
"memory": 437.5,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.4476,
"burstable": false,
"instanceType": "Standard_M32ls",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 8.9117,
"burstable": false,
"instanceType": "Standard_M32ms",
"memory": 875.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.2484,
"burstable": false,
"instanceType": "Standard_M32ts",
"memory": 192.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 6.498,
"burstable": false,
"instanceType": "Standard_M64ls",
"memory": 512.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 14.99,
"burstable": false,
"instanceType": "Standard_M64ms",
"memory": 1750.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 9.671,
"burstable": false,
"instanceType": "Standard_M64s",
"memory": 1000.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 38.701,
"burstable": false,
"instanceType": "Standard_M128ms",
"memory": 3800.0,
"cpu": 128
},
{
"baseline": 1.0,
"generation": "current",
"price": 19.342,
"burstable": false,
"instanceType": "Standard_M128s",
"memory": 2000.0,
"cpu": 128
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.038,
"burstable": false,
"instanceType": "Standard_NC6s_v2",
"memory": 112.0,
"cpu": 6
},
{
"baseline": 1.0,
"generation": "current",
"price": 6.077,
"burstable": false,
"instanceType": "Standard_NC12s_v2",
"memory": 224.0,
"cpu": 12
},
{
"baseline": 1.0,
"generation": "current",
"price": 13.37,
"burstable": false,
"instanceType": "Standard_NC24rs_v2",
"memory": 448.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 12.153,
"burstable": false,
"instanceType": "Standard_NC24s_v2",
"memory": 448.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.374,
"burstable": false,
"instanceType": "Standard_L8s_v2",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.748,
"burstable": false,
"instanceType": "Standard_L16s_v2",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 7.48,
"burstable": false,
"instanceType": "Standard_L80s_v2",
"memory": 640.0,
"cpu": 80
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.66,
"burstable": false,
"instanceType": "Standard_G1",
"memory": 28.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.32,
"burstable": false,
"instanceType": "Standard_G2",
"memory": 56.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.64,
"burstable": false,
"instanceType": "Standard_G3",
"memory": 112.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.28,
"burstable": false,
"instanceType": "Standard_G4",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 9.39,
"burstable": false,
"instanceType": "Standard_G5",
"memory": 448.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.66,
"burstable": false,
"instanceType": "Standard_GS1",
"memory": 28.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.32,
"burstable": false,
"instanceType": "Standard_GS2",
"memory": 56.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.64,
"burstable": false,
"instanceType": "Standard_GS3",
"memory": 112.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.28,
"burstable": false,
"instanceType": "Standard_GS4",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.28,
"burstable": false,
"instanceType": "Standard_GS4-4",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.28,
"burstable": false,
"instanceType": "Standard_GS4-8",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 9.39,
"burstable": false,
"instanceType": "Standard_GS5",
"memory": 448.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 9.39,
"burstable": false,
"instanceType": "Standard_GS5-8",
"memory": 448.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 9.39,
"burstable": false,
"instanceType": "Standard_GS5-16",
"memory": 448.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.374,
"burstable": false,
"instanceType": "Standard_L4s",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.748,
"burstable": false,
"instanceType": "Standard_L8s",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.496,
"burstable": false,
"instanceType": "Standard_L16s",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.992,
"burstable": false,
"instanceType": "Standard_L32s",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.098,
"burstable": false,
"instanceType": "Standard_F2s_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.196,
"burstable": false,
"instanceType": "Standard_F4s_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.392,
"burstable": false,
"instanceType": "Standard_F8s_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.784,
"burstable": false,
"instanceType": "Standard_F16s_v2",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.568,
"burstable": false,
"instanceType": "Standard_F32s_v2",
"memory": 64.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.136,
"burstable": false,
"instanceType": "Standard_F64s_v2",
"memory": 128.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.528,
"burstable": false,
"instanceType": "Standard_F72s_v2",
"memory": 144.0,
"cpu": 72
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.038,
"burstable": false,
"instanceType": "Standard_ND6s",
"memory": 112.0,
"cpu": 6
},
{
"baseline": 1.0,
"generation": "current",
"price": 6.077,
"burstable": false,
"instanceType": "Standard_ND12s",
"memory": 224.0,
"cpu": 12
},
{
"baseline": 1.0,
"generation": "current",
"price": 13.37,
"burstable": false,
"instanceType": "Standard_ND24rs",
"memory": 448.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 12.153,
"burstable": false,
"instanceType": "Standard_ND24s",
"memory": 448.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.925,
"burstable": false,
"instanceType": "Standard_H8",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.848,
"burstable": false,
"instanceType": "Standard_H16",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.238,
"burstable": false,
"instanceType": "Standard_H8m",
"memory": 112.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.476,
"burstable": false,
"instanceType": "Standard_H16m",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.033,
"burstable": false,
"instanceType": "Standard_H16r",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.724,
"burstable": false,
"instanceType": "Standard_H16mr",
"memory": 224.0,
"cpu": 16
}
],
"Australia Southeast": [
{
"baseline": 1.0,
"generation": "current",
"price": 0.029,
"burstable": false,
"instanceType": "Standard_A0",
"memory": 0.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.071,
"burstable": false,
"instanceType": "Standard_A1",
"memory": 1.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.142,
"burstable": false,
"instanceType": "Standard_A2",
"memory": 3.5,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.284,
"burstable": false,
"instanceType": "Standard_A3",
"memory": 7.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.278,
"burstable": false,
"instanceType": "Standard_A5",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.464,
"burstable": false,
"instanceType": "Standard_A4",
"memory": 14.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.556,
"burstable": false,
"instanceType": "Standard_A6",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.112,
"burstable": false,
"instanceType": "Standard_A7",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.093,
"burstable": false,
"instanceType": "Standard_D1",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.186,
"burstable": false,
"instanceType": "Standard_D2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.372,
"burstable": false,
"instanceType": "Standard_D3",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.744,
"burstable": false,
"instanceType": "Standard_D4",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.21,
"burstable": false,
"instanceType": "Standard_D11",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.42,
"burstable": false,
"instanceType": "Standard_D12",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.84,
"burstable": false,
"instanceType": "Standard_D13",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.68,
"burstable": false,
"instanceType": "Standard_D14",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.05,
"burstable": false,
"instanceType": "Standard_A1_v2",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.178,
"burstable": false,
"instanceType": "Standard_A2m_v2",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.106,
"burstable": false,
"instanceType": "Standard_A2_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.374,
"burstable": false,
"instanceType": "Standard_A4m_v2",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.222,
"burstable": false,
"instanceType": "Standard_A4_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.786,
"burstable": false,
"instanceType": "Standard_A8m_v2",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.467,
"burstable": false,
"instanceType": "Standard_A8_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.2279,
"burstable": false,
"instanceType": "Standard_M8ms",
"memory": 218.75,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.4559,
"burstable": false,
"instanceType": "Standard_M16ms",
"memory": 437.5,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.4476,
"burstable": false,
"instanceType": "Standard_M32ls",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 8.9117,
"burstable": false,
"instanceType": "Standard_M32ms",
"memory": 875.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.2484,
"burstable": false,
"instanceType": "Standard_M32ts",
"memory": 192.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 6.498,
"burstable": false,
"instanceType": "Standard_M64ls",
"memory": 512.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 14.99,
"burstable": false,
"instanceType": "Standard_M64ms",
"memory": 1750.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 9.671,
"burstable": false,
"instanceType": "Standard_M64s",
"memory": 1000.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 38.701,
"burstable": false,
"instanceType": "Standard_M128ms",
"memory": 3800.0,
"cpu": 128
},
{
"baseline": 1.0,
"generation": "current",
"price": 19.341,
"burstable": false,
"instanceType": "Standard_M128s",
"memory": 2000.0,
"cpu": 128
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.093,
"burstable": false,
"instanceType": "Standard_DS1",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.186,
"burstable": false,
"instanceType": "Standard_DS2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.372,
"burstable": false,
"instanceType": "Standard_DS3",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.744,
"burstable": false,
"instanceType": "Standard_DS4",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.21,
"burstable": false,
"instanceType": "Standard_DS11",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.42,
"burstable": false,
"instanceType": "Standard_DS12",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.84,
"burstable": false,
"instanceType": "Standard_DS13",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.68,
"burstable": false,
"instanceType": "Standard_DS14",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 0.2,
"generation": "current",
"price": 0.032,
"burstable": true,
"instanceType": "Standard_B1ms",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 0.1,
"generation": "current",
"price": 0.016,
"burstable": true,
"instanceType": "Standard_B1s",
"memory": 1.0,
"cpu": 1
},
{
"baseline": 0.6,
"generation": "current",
"price": 0.128,
"burstable": true,
"instanceType": "Standard_B2ms",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 0.4,
"generation": "current",
"price": 0.064,
"burstable": true,
"instanceType": "Standard_B2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 0.9,
"generation": "current",
"price": 0.256,
"burstable": true,
"instanceType": "Standard_B4ms",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.35,
"generation": "current",
"price": 0.512,
"burstable": true,
"instanceType": "Standard_B8ms",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.078,
"burstable": false,
"instanceType": "Standard_D1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.15576,
"burstable": false,
"instanceType": "Standard_D2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.311,
"burstable": false,
"instanceType": "Standard_D3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.623,
"burstable": false,
"instanceType": "Standard_D4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.246,
"burstable": false,
"instanceType": "Standard_D5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.2,
"burstable": false,
"instanceType": "Standard_D11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.399,
"burstable": false,
"instanceType": "Standard_D12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.798,
"burstable": false,
"instanceType": "Standard_D13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.596,
"burstable": false,
"instanceType": "Standard_D14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.15576,
"burstable": false,
"instanceType": "Standard_D2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.311,
"burstable": false,
"instanceType": "Standard_D3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.623,
"burstable": false,
"instanceType": "Standard_D4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.246,
"burstable": false,
"instanceType": "Standard_D5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.2,
"burstable": false,
"instanceType": "Standard_D11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.399,
"burstable": false,
"instanceType": "Standard_D12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.798,
"burstable": false,
"instanceType": "Standard_D13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.596,
"burstable": false,
"instanceType": "Standard_D14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.065,
"burstable": false,
"instanceType": "Standard_F1",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.13,
"burstable": false,
"instanceType": "Standard_F2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.26,
"burstable": false,
"instanceType": "Standard_F4",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.521,
"burstable": false,
"instanceType": "Standard_F8",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.042,
"burstable": false,
"instanceType": "Standard_F16",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.078,
"burstable": false,
"instanceType": "Standard_DS1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.15576,
"burstable": false,
"instanceType": "Standard_DS2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.311,
"burstable": false,
"instanceType": "Standard_DS3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.623,
"burstable": false,
"instanceType": "Standard_DS4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.246,
"burstable": false,
"instanceType": "Standard_DS5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.2,
"burstable": false,
"instanceType": "Standard_DS11-1_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.2,
"burstable": false,
"instanceType": "Standard_DS11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.399,
"burstable": false,
"instanceType": "Standard_DS12-1_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.399,
"burstable": false,
"instanceType": "Standard_DS12-2_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.399,
"burstable": false,
"instanceType": "Standard_DS12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.798,
"burstable": false,
"instanceType": "Standard_DS13-2_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.798,
"burstable": false,
"instanceType": "Standard_DS13-4_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.798,
"burstable": false,
"instanceType": "Standard_DS13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.596,
"burstable": false,
"instanceType": "Standard_DS14-4_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.596,
"burstable": false,
"instanceType": "Standard_DS14-8_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.596,
"burstable": false,
"instanceType": "Standard_DS14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.15576,
"burstable": false,
"instanceType": "Standard_DS2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.311,
"burstable": false,
"instanceType": "Standard_DS3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.623,
"burstable": false,
"instanceType": "Standard_DS4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.246,
"burstable": false,
"instanceType": "Standard_DS5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.2,
"burstable": false,
"instanceType": "Standard_DS11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.399,
"burstable": false,
"instanceType": "Standard_DS12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.798,
"burstable": false,
"instanceType": "Standard_DS13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.596,
"burstable": false,
"instanceType": "Standard_DS14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.065,
"burstable": false,
"instanceType": "Standard_F1s",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.13,
"burstable": false,
"instanceType": "Standard_F2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.26,
"burstable": false,
"instanceType": "Standard_F4s",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.521,
"burstable": false,
"instanceType": "Standard_F8s",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.042,
"burstable": false,
"instanceType": "Standard_F16s",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.125,
"burstable": false,
"instanceType": "Standard_D2_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.25,
"burstable": false,
"instanceType": "Standard_D4_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.5,
"burstable": false,
"instanceType": "Standard_D8_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.0,
"burstable": false,
"instanceType": "Standard_D16_v3",
"memory": 64.1,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.0,
"burstable": false,
"instanceType": "Standard_D32_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.0,
"burstable": false,
"instanceType": "Standard_D64_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.125,
"burstable": false,
"instanceType": "Standard_D2s_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.25,
"burstable": false,
"instanceType": "Standard_D4s_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.5,
"burstable": false,
"instanceType": "Standard_D8s_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.0,
"burstable": false,
"instanceType": "Standard_D16s_v3",
"memory": 64.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.0,
"burstable": false,
"instanceType": "Standard_D32s_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.0,
"burstable": false,
"instanceType": "Standard_D64s_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.16,
"burstable": false,
"instanceType": "Standard_E2_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.319,
"burstable": false,
"instanceType": "Standard_E4_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.638,
"burstable": false,
"instanceType": "Standard_E8_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.277,
"burstable": false,
"instanceType": "Standard_E16_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.6,
"burstable": false,
"instanceType": "Standard_E20_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.554,
"burstable": false,
"instanceType": "Standard_E32_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.347,
"burstable": false,
"instanceType": "Standard_E64i_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.347,
"burstable": false,
"instanceType": "Standard_E64_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.16,
"burstable": false,
"instanceType": "Standard_E2s_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.319,
"burstable": false,
"instanceType": "Standard_E4s_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.638,
"burstable": false,
"instanceType": "Standard_E8s_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.277,
"burstable": false,
"instanceType": "Standard_E16s_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.6,
"burstable": false,
"instanceType": "Standard_E20s_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.554,
"burstable": false,
"instanceType": "Standard_E32s_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.347,
"burstable": false,
"instanceType": "Standard_E64is_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.347,
"burstable": false,
"instanceType": "Standard_E64s_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.995,
"burstable": false,
"instanceType": "Standard_D15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.995,
"burstable": false,
"instanceType": "Standard_DS15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.111,
"burstable": false,
"instanceType": "Standard_F2s_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.223,
"burstable": false,
"instanceType": "Standard_F4s_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.445,
"burstable": false,
"instanceType": "Standard_F8s_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.891,
"burstable": false,
"instanceType": "Standard_F16s_v2",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.782,
"burstable": false,
"instanceType": "Standard_F32s_v2",
"memory": 64.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.563,
"burstable": false,
"instanceType": "Standard_F64s_v2",
"memory": 128.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.009,
"burstable": false,
"instanceType": "Standard_F72s_v2",
"memory": 144.0,
"cpu": 72
}
],
"Australia East": [
{
"baseline": 1.0,
"generation": "current",
"price": 0.638,
"burstable": false,
"instanceType": "Standard_G1",
"memory": 28.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.276,
"burstable": false,
"instanceType": "Standard_G2",
"memory": 56.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.552,
"burstable": false,
"instanceType": "Standard_G3",
"memory": 112.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.104,
"burstable": false,
"instanceType": "Standard_G4",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 10.208,
"burstable": false,
"instanceType": "Standard_G5",
"memory": 448.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.638,
"burstable": false,
"instanceType": "Standard_GS1",
"memory": 28.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.276,
"burstable": false,
"instanceType": "Standard_GS2",
"memory": 56.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.552,
"burstable": false,
"instanceType": "Standard_GS3",
"memory": 112.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.104,
"burstable": false,
"instanceType": "Standard_GS4",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.104,
"burstable": false,
"instanceType": "Standard_GS4-4",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.104,
"burstable": false,
"instanceType": "Standard_GS4-8",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 10.208,
"burstable": false,
"instanceType": "Standard_GS5",
"memory": 448.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 10.208,
"burstable": false,
"instanceType": "Standard_GS5-8",
"memory": 448.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 10.208,
"burstable": false,
"instanceType": "Standard_GS5-16",
"memory": 448.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.374,
"burstable": false,
"instanceType": "Standard_L4s",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.748,
"burstable": false,
"instanceType": "Standard_L8s",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.496,
"burstable": false,
"instanceType": "Standard_L16s",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.992,
"burstable": false,
"instanceType": "Standard_L32s",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 0.2,
"generation": "current",
"price": 0.0264,
"burstable": true,
"instanceType": "Standard_B1ms",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 0.1,
"generation": "current",
"price": 0.0132,
"burstable": true,
"instanceType": "Standard_B1s",
"memory": 1.0,
"cpu": 1
},
{
"baseline": 0.6,
"generation": "current",
"price": 0.106,
"burstable": true,
"instanceType": "Standard_B2ms",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 0.4,
"generation": "current",
"price": 0.0528,
"burstable": true,
"instanceType": "Standard_B2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 0.9,
"generation": "current",
"price": 0.211,
"burstable": true,
"instanceType": "Standard_B4ms",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.35,
"generation": "current",
"price": 0.422,
"burstable": true,
"instanceType": "Standard_B8ms",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.084,
"burstable": false,
"instanceType": "Standard_D1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.168,
"burstable": false,
"instanceType": "Standard_D2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.336,
"burstable": false,
"instanceType": "Standard_D3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.673,
"burstable": false,
"instanceType": "Standard_D4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.345,
"burstable": false,
"instanceType": "Standard_D5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.2,
"burstable": false,
"instanceType": "Standard_D11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.399,
"burstable": false,
"instanceType": "Standard_D12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.798,
"burstable": false,
"instanceType": "Standard_D13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.596,
"burstable": false,
"instanceType": "Standard_D14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.168,
"burstable": false,
"instanceType": "Standard_D2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.336,
"burstable": false,
"instanceType": "Standard_D3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.673,
"burstable": false,
"instanceType": "Standard_D4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.345,
"burstable": false,
"instanceType": "Standard_D5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.2,
"burstable": false,
"instanceType": "Standard_D11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.399,
"burstable": false,
"instanceType": "Standard_D12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.798,
"burstable": false,
"instanceType": "Standard_D13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.596,
"burstable": false,
"instanceType": "Standard_D14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.065,
"burstable": false,
"instanceType": "Standard_F1",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.13,
"burstable": false,
"instanceType": "Standard_F2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.26,
"burstable": false,
"instanceType": "Standard_F4",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.521,
"burstable": false,
"instanceType": "Standard_F8",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.042,
"burstable": false,
"instanceType": "Standard_F16",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.084,
"burstable": false,
"instanceType": "Standard_DS1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.168,
"burstable": false,
"instanceType": "Standard_DS2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.336,
"burstable": false,
"instanceType": "Standard_DS3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.673,
"burstable": false,
"instanceType": "Standard_DS4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.345,
"burstable": false,
"instanceType": "Standard_DS5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.2,
"burstable": false,
"instanceType": "Standard_DS11-1_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.2,
"burstable": false,
"instanceType": "Standard_DS11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.399,
"burstable": false,
"instanceType": "Standard_DS12-1_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.399,
"burstable": false,
"instanceType": "Standard_DS12-2_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.399,
"burstable": false,
"instanceType": "Standard_DS12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.798,
"burstable": false,
"instanceType": "Standard_DS13-2_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.798,
"burstable": false,
"instanceType": "Standard_DS13-4_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.798,
"burstable": false,
"instanceType": "Standard_DS13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.596,
"burstable": false,
"instanceType": "Standard_DS14-4_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.596,
"burstable": false,
"instanceType": "Standard_DS14-8_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.596,
"burstable": false,
"instanceType": "Standard_DS14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.168,
"burstable": false,
"instanceType": "Standard_DS2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.336,
"burstable": false,
"instanceType": "Standard_DS3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.673,
"burstable": false,
"instanceType": "Standard_DS4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.345,
"burstable": false,
"instanceType": "Standard_DS5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.2,
"burstable": false,
"instanceType": "Standard_DS11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.399,
"burstable": false,
"instanceType": "Standard_DS12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.798,
"burstable": false,
"instanceType": "Standard_DS13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.596,
"burstable": false,
"instanceType": "Standard_DS14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.065,
"burstable": false,
"instanceType": "Standard_F1s",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.13,
"burstable": false,
"instanceType": "Standard_F2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.26,
"burstable": false,
"instanceType": "Standard_F4s",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.521,
"burstable": false,
"instanceType": "Standard_F8s",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.042,
"burstable": false,
"instanceType": "Standard_F16s",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.05,
"burstable": false,
"instanceType": "Standard_A1_v2",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.149,
"burstable": false,
"instanceType": "Standard_A2m_v2",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.106,
"burstable": false,
"instanceType": "Standard_A2_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.312,
"burstable": false,
"instanceType": "Standard_A4m_v2",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.222,
"burstable": false,
"instanceType": "Standard_A4_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.655,
"burstable": false,
"instanceType": "Standard_A8m_v2",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.467,
"burstable": false,
"instanceType": "Standard_A8_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.125,
"burstable": false,
"instanceType": "Standard_D2_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.25,
"burstable": false,
"instanceType": "Standard_D4_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.5,
"burstable": false,
"instanceType": "Standard_D8_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.0,
"burstable": false,
"instanceType": "Standard_D16_v3",
"memory": 64.1,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.0,
"burstable": false,
"instanceType": "Standard_D32_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.0,
"burstable": false,
"instanceType": "Standard_D64_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.125,
"burstable": false,
"instanceType": "Standard_D2s_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.25,
"burstable": false,
"instanceType": "Standard_D4s_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.5,
"burstable": false,
"instanceType": "Standard_D8s_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.0,
"burstable": false,
"instanceType": "Standard_D16s_v3",
"memory": 64.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.0,
"burstable": false,
"instanceType": "Standard_D32s_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.0,
"burstable": false,
"instanceType": "Standard_D64s_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.16,
"burstable": false,
"instanceType": "Standard_E2_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.319,
"burstable": false,
"instanceType": "Standard_E4_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.638,
"burstable": false,
"instanceType": "Standard_E8_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.277,
"burstable": false,
"instanceType": "Standard_E16_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.554,
"burstable": false,
"instanceType": "Standard_E32_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.347,
"burstable": false,
"instanceType": "Standard_E64i_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.347,
"burstable": false,
"instanceType": "Standard_E64_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.16,
"burstable": false,
"instanceType": "Standard_E2s_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.319,
"burstable": false,
"instanceType": "Standard_E4s_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.638,
"burstable": false,
"instanceType": "Standard_E8s_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.277,
"burstable": false,
"instanceType": "Standard_E16s_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.554,
"burstable": false,
"instanceType": "Standard_E32s_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.347,
"burstable": false,
"instanceType": "Standard_E64is_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.347,
"burstable": false,
"instanceType": "Standard_E64s_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.2279,
"burstable": false,
"instanceType": "Standard_M8ms",
"memory": 218.75,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.4559,
"burstable": false,
"instanceType": "Standard_M16ms",
"memory": 437.5,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.4476,
"burstable": false,
"instanceType": "Standard_M32ls",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 8.9117,
"burstable": false,
"instanceType": "Standard_M32ms",
"memory": 875.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.2484,
"burstable": false,
"instanceType": "Standard_M32ts",
"memory": 192.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 6.498,
"burstable": false,
"instanceType": "Standard_M64ls",
"memory": 512.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 14.99,
"burstable": false,
"instanceType": "Standard_M64ms",
"memory": 1750.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 9.671,
"burstable": false,
"instanceType": "Standard_M64s",
"memory": 1000.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 38.6976,
"burstable": false,
"instanceType": "Standard_M128ms",
"memory": 3800.0,
"cpu": 128
},
{
"baseline": 1.0,
"generation": "current",
"price": 19.341,
"burstable": false,
"instanceType": "Standard_M128s",
"memory": 2000.0,
"cpu": 128
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.024,
"burstable": false,
"instanceType": "Standard_A0",
"memory": 0.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.032,
"burstable": false,
"instanceType": "Standard_A1",
"memory": 1.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.142,
"burstable": false,
"instanceType": "Standard_A2",
"memory": 3.5,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.232,
"burstable": false,
"instanceType": "Standard_A3",
"memory": 7.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.278,
"burstable": false,
"instanceType": "Standard_A5",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.464,
"burstable": false,
"instanceType": "Standard_A4",
"memory": 14.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.556,
"burstable": false,
"instanceType": "Standard_A6",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.112,
"burstable": false,
"instanceType": "Standard_A7",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.995,
"burstable": false,
"instanceType": "Standard_D15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.093,
"burstable": false,
"instanceType": "Standard_D1",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.186,
"burstable": false,
"instanceType": "Standard_D2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.372,
"burstable": false,
"instanceType": "Standard_D3",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.744,
"burstable": false,
"instanceType": "Standard_D4",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.21,
"burstable": false,
"instanceType": "Standard_D11",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.42,
"burstable": false,
"instanceType": "Standard_D12",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.84,
"burstable": false,
"instanceType": "Standard_D13",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.68,
"burstable": false,
"instanceType": "Standard_D14",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.185,
"burstable": false,
"instanceType": "Standard_H8",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.369,
"burstable": false,
"instanceType": "Standard_H16",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.587,
"burstable": false,
"instanceType": "Standard_H8m",
"memory": 112.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.175,
"burstable": false,
"instanceType": "Standard_H16m",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.606,
"burstable": false,
"instanceType": "Standard_H16r",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.492,
"burstable": false,
"instanceType": "Standard_H16mr",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.995,
"burstable": false,
"instanceType": "Standard_DS15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.59,
"burstable": false,
"instanceType": "Standard_NV6",
"memory": 56.0,
"cpu": 6
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.18,
"burstable": false,
"instanceType": "Standard_NV12",
"memory": 112.0,
"cpu": 12
},
{
"baseline": 1.0,
"generation": "current",
"price": 6.36,
"burstable": false,
"instanceType": "Standard_NV24",
"memory": 224.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.6,
"burstable": false,
"instanceType": "Standard_E20_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.6,
"burstable": false,
"instanceType": "Standard_E20s_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.093,
"burstable": false,
"instanceType": "Standard_DS1",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.186,
"burstable": false,
"instanceType": "Standard_DS2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.372,
"burstable": false,
"instanceType": "Standard_DS3",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.744,
"burstable": false,
"instanceType": "Standard_DS4",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.21,
"burstable": false,
"instanceType": "Standard_DS11",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.42,
"burstable": false,
"instanceType": "Standard_DS12",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.84,
"burstable": false,
"instanceType": "Standard_DS13",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.68,
"burstable": false,
"instanceType": "Standard_DS14",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.24178,
"burstable": false,
"instanceType": "Standard_NC6s_v3",
"memory": 112.0,
"cpu": 6
},
{
"baseline": 1.0,
"generation": "current",
"price": 10.48356,
"burstable": false,
"instanceType": "Standard_NC12s_v3",
"memory": 224.0,
"cpu": 12
},
{
"baseline": 1.0,
"generation": "current",
"price": 23.063832,
"burstable": false,
"instanceType": "Standard_NC24rs_v3",
"memory": 448.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 20.96712,
"burstable": false,
"instanceType": "Standard_NC24s_v3",
"memory": 448.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.55,
"burstable": false,
"instanceType": "Standard_NC6",
"memory": 56.0,
"cpu": 6
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.11,
"burstable": false,
"instanceType": "Standard_NC12",
"memory": 112.0,
"cpu": 12
},
{
"baseline": 1.0,
"generation": "current",
"price": 6.22,
"burstable": false,
"instanceType": "Standard_NC24",
"memory": 224.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.111,
"burstable": false,
"instanceType": "Standard_F2s_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.222,
"burstable": false,
"instanceType": "Standard_F4s_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.444,
"burstable": false,
"instanceType": "Standard_F8s_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.888,
"burstable": false,
"instanceType": "Standard_F16s_v2",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.776,
"burstable": false,
"instanceType": "Standard_F32s_v2",
"memory": 64.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.552,
"burstable": false,
"instanceType": "Standard_F64s_v2",
"memory": 128.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.996,
"burstable": false,
"instanceType": "Standard_F72s_v2",
"memory": 144.0,
"cpu": 72
}
],
"West US 2": [
{
"baseline": 1.0,
"generation": "current",
"price": 0.085,
"burstable": false,
"instanceType": "Standard_F2s_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.17,
"burstable": false,
"instanceType": "Standard_F4s_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.34,
"burstable": false,
"instanceType": "Standard_F8s_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.68,
"burstable": false,
"instanceType": "Standard_F16s_v2",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.36,
"burstable": false,
"instanceType": "Standard_F32s_v2",
"memory": 64.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.72,
"burstable": false,
"instanceType": "Standard_F64s_v2",
"memory": 128.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.06,
"burstable": false,
"instanceType": "Standard_F72s_v2",
"memory": 144.0,
"cpu": 72
},
{
"baseline": 0.2,
"generation": "current",
"price": 0.0208,
"burstable": true,
"instanceType": "Standard_B1ms",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 0.1,
"generation": "current",
"price": 0.0104,
"burstable": true,
"instanceType": "Standard_B1s",
"memory": 1.0,
"cpu": 1
},
{
"baseline": 0.6,
"generation": "current",
"price": 0.0832,
"burstable": true,
"instanceType": "Standard_B2ms",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 0.4,
"generation": "current",
"price": 0.0416,
"burstable": true,
"instanceType": "Standard_B2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 0.9,
"generation": "current",
"price": 0.166,
"burstable": true,
"instanceType": "Standard_B4ms",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.35,
"generation": "current",
"price": 0.333,
"burstable": true,
"instanceType": "Standard_B8ms",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.018,
"burstable": false,
"instanceType": "Standard_A0",
"memory": 0.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.023,
"burstable": false,
"instanceType": "Standard_A1",
"memory": 1.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.101,
"burstable": false,
"instanceType": "Standard_A2",
"memory": 3.5,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.176,
"burstable": false,
"instanceType": "Standard_A3",
"memory": 7.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.22,
"burstable": false,
"instanceType": "Standard_A5",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.405,
"burstable": false,
"instanceType": "Standard_A4",
"memory": 14.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.44,
"burstable": false,
"instanceType": "Standard_A6",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.88,
"burstable": false,
"instanceType": "Standard_A7",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.057,
"burstable": false,
"instanceType": "Standard_D1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.114,
"burstable": false,
"instanceType": "Standard_D2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.229,
"burstable": false,
"instanceType": "Standard_D3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.458,
"burstable": false,
"instanceType": "Standard_D4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.916,
"burstable": false,
"instanceType": "Standard_D5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.149,
"burstable": false,
"instanceType": "Standard_D11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.299,
"burstable": false,
"instanceType": "Standard_D12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.598,
"burstable": false,
"instanceType": "Standard_D13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.196,
"burstable": false,
"instanceType": "Standard_D14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.495,
"burstable": false,
"instanceType": "Standard_D15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.114,
"burstable": false,
"instanceType": "Standard_D2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.229,
"burstable": false,
"instanceType": "Standard_D3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.458,
"burstable": false,
"instanceType": "Standard_D4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.916,
"burstable": false,
"instanceType": "Standard_D5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.149,
"burstable": false,
"instanceType": "Standard_D11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.299,
"burstable": false,
"instanceType": "Standard_D12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.598,
"burstable": false,
"instanceType": "Standard_D13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.196,
"burstable": false,
"instanceType": "Standard_D14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.05,
"burstable": false,
"instanceType": "Standard_F1",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.099,
"burstable": false,
"instanceType": "Standard_F2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.199,
"burstable": false,
"instanceType": "Standard_F4",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.398,
"burstable": false,
"instanceType": "Standard_F8",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.796,
"burstable": false,
"instanceType": "Standard_F16",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.057,
"burstable": false,
"instanceType": "Standard_DS1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.114,
"burstable": false,
"instanceType": "Standard_DS2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.229,
"burstable": false,
"instanceType": "Standard_DS3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.458,
"burstable": false,
"instanceType": "Standard_DS4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.916,
"burstable": false,
"instanceType": "Standard_DS5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.149,
"burstable": false,
"instanceType": "Standard_DS11-1_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.149,
"burstable": false,
"instanceType": "Standard_DS11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.299,
"burstable": false,
"instanceType": "Standard_DS12-1_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.299,
"burstable": false,
"instanceType": "Standard_DS12-2_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.299,
"burstable": false,
"instanceType": "Standard_DS12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.598,
"burstable": false,
"instanceType": "Standard_DS13-2_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.598,
"burstable": false,
"instanceType": "Standard_DS13-4_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.598,
"burstable": false,
"instanceType": "Standard_DS13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.196,
"burstable": false,
"instanceType": "Standard_DS14-4_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.196,
"burstable": false,
"instanceType": "Standard_DS14-8_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.196,
"burstable": false,
"instanceType": "Standard_DS14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.495,
"burstable": false,
"instanceType": "Standard_DS15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.114,
"burstable": false,
"instanceType": "Standard_DS2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.229,
"burstable": false,
"instanceType": "Standard_DS3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.458,
"burstable": false,
"instanceType": "Standard_DS4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.916,
"burstable": false,
"instanceType": "Standard_DS5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.149,
"burstable": false,
"instanceType": "Standard_DS11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.299,
"burstable": false,
"instanceType": "Standard_DS12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.598,
"burstable": false,
"instanceType": "Standard_DS13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.196,
"burstable": false,
"instanceType": "Standard_DS14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.05,
"burstable": false,
"instanceType": "Standard_F1s",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.099,
"burstable": false,
"instanceType": "Standard_F2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.199,
"burstable": false,
"instanceType": "Standard_F4s",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.398,
"burstable": false,
"instanceType": "Standard_F8s",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.796,
"burstable": false,
"instanceType": "Standard_F16s",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.036,
"burstable": false,
"instanceType": "Standard_A1_v2",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.099,
"burstable": false,
"instanceType": "Standard_A2m_v2",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.076,
"burstable": false,
"instanceType": "Standard_A2_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.208,
"burstable": false,
"instanceType": "Standard_A4m_v2",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.159,
"burstable": false,
"instanceType": "Standard_A4_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.437,
"burstable": false,
"instanceType": "Standard_A8m_v2",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.333,
"burstable": false,
"instanceType": "Standard_A8_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.096,
"burstable": false,
"instanceType": "Standard_D2_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.192,
"burstable": false,
"instanceType": "Standard_D4_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.384,
"burstable": false,
"instanceType": "Standard_D8_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.768,
"burstable": false,
"instanceType": "Standard_D16_v3",
"memory": 64.1,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.536,
"burstable": false,
"instanceType": "Standard_D32_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.096,
"burstable": false,
"instanceType": "Standard_D2s_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.192,
"burstable": false,
"instanceType": "Standard_D4s_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.384,
"burstable": false,
"instanceType": "Standard_D8s_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.768,
"burstable": false,
"instanceType": "Standard_D16s_v3",
"memory": 64.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.536,
"burstable": false,
"instanceType": "Standard_D32s_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.873,
"burstable": false,
"instanceType": "Standard_M32ls",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 6.146,
"burstable": false,
"instanceType": "Standard_M32ms",
"memory": 875.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.707,
"burstable": false,
"instanceType": "Standard_M32ts",
"memory": 192.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 5.415,
"burstable": false,
"instanceType": "Standard_M64ls",
"memory": 512.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 10.337,
"burstable": false,
"instanceType": "Standard_M64ms",
"memory": 1750.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 6.669,
"burstable": false,
"instanceType": "Standard_M64s",
"memory": 1000.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 26.688,
"burstable": false,
"instanceType": "Standard_M128ms",
"memory": 3800.0,
"cpu": 128
},
{
"baseline": 1.0,
"generation": "current",
"price": 13.338,
"burstable": false,
"instanceType": "Standard_M128s",
"memory": 2000.0,
"cpu": 128
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.072,
"burstable": false,
"instanceType": "Standard_D64_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.072,
"burstable": false,
"instanceType": "Standard_D64s_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.126,
"burstable": false,
"instanceType": "Standard_E2_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.252,
"burstable": false,
"instanceType": "Standard_E4_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.504,
"burstable": false,
"instanceType": "Standard_E8_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.008,
"burstable": false,
"instanceType": "Standard_E16_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.26,
"burstable": false,
"instanceType": "Standard_E20_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.016,
"burstable": false,
"instanceType": "Standard_E32_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.629,
"burstable": false,
"instanceType": "Standard_E64i_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.629,
"burstable": false,
"instanceType": "Standard_E64_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.126,
"burstable": false,
"instanceType": "Standard_E2s_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.252,
"burstable": false,
"instanceType": "Standard_E4s_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.504,
"burstable": false,
"instanceType": "Standard_E8s_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.008,
"burstable": false,
"instanceType": "Standard_E16s_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.26,
"burstable": false,
"instanceType": "Standard_E20s_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.016,
"burstable": false,
"instanceType": "Standard_E32s_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.629,
"burstable": false,
"instanceType": "Standard_E64is_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.629,
"burstable": false,
"instanceType": "Standard_E64s_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.07,
"burstable": false,
"instanceType": "Standard_NC6s_v2",
"memory": 112.0,
"cpu": 6
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.14,
"burstable": false,
"instanceType": "Standard_NC12s_v2",
"memory": 224.0,
"cpu": 12
},
{
"baseline": 1.0,
"generation": "current",
"price": 9.108,
"burstable": false,
"instanceType": "Standard_NC24rs_v2",
"memory": 448.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 8.28,
"burstable": false,
"instanceType": "Standard_NC24s_v2",
"memory": 448.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.796,
"burstable": false,
"instanceType": "Standard_H8",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.591,
"burstable": false,
"instanceType": "Standard_H16",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.066,
"burstable": false,
"instanceType": "Standard_H8m",
"memory": 112.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.132,
"burstable": false,
"instanceType": "Standard_H16m",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.75,
"burstable": false,
"instanceType": "Standard_H16r",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.345,
"burstable": false,
"instanceType": "Standard_H16mr",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.06,
"burstable": false,
"instanceType": "Standard_NC6s_v3",
"memory": 112.0,
"cpu": 6
},
{
"baseline": 1.0,
"generation": "current",
"price": 6.12,
"burstable": false,
"instanceType": "Standard_NC12s_v3",
"memory": 224.0,
"cpu": 12
},
{
"baseline": 1.0,
"generation": "current",
"price": 13.464,
"burstable": false,
"instanceType": "Standard_NC24rs_v3",
"memory": 448.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 12.24,
"burstable": false,
"instanceType": "Standard_NC24s_v3",
"memory": 448.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.584,
"burstable": false,
"instanceType": "Standard_HC44rs",
"memory": 327.83,
"cpu": 44
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.9,
"burstable": false,
"instanceType": "Standard_NC6",
"memory": 56.0,
"cpu": 6
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.8,
"burstable": false,
"instanceType": "Standard_NC12",
"memory": 112.0,
"cpu": 12
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.6,
"burstable": false,
"instanceType": "Standard_NC24",
"memory": 224.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.49,
"burstable": false,
"instanceType": "Standard_G1",
"memory": 28.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.981,
"burstable": false,
"instanceType": "Standard_G2",
"memory": 56.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.961,
"burstable": false,
"instanceType": "Standard_G3",
"memory": 112.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.922,
"burstable": false,
"instanceType": "Standard_G4",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 7.843,
"burstable": false,
"instanceType": "Standard_G5",
"memory": 448.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.49,
"burstable": false,
"instanceType": "Standard_GS1",
"memory": 28.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.981,
"burstable": false,
"instanceType": "Standard_GS2",
"memory": 56.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.961,
"burstable": false,
"instanceType": "Standard_GS3",
"memory": 112.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.922,
"burstable": false,
"instanceType": "Standard_GS4",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.922,
"burstable": false,
"instanceType": "Standard_GS4-4",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.922,
"burstable": false,
"instanceType": "Standard_GS4-8",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 7.843,
"burstable": false,
"instanceType": "Standard_GS5",
"memory": 448.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 7.843,
"burstable": false,
"instanceType": "Standard_GS5-8",
"memory": 448.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 7.843,
"burstable": false,
"instanceType": "Standard_GS5-16",
"memory": 448.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.312,
"burstable": false,
"instanceType": "Standard_L4s",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.624,
"burstable": false,
"instanceType": "Standard_L8s",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.248,
"burstable": false,
"instanceType": "Standard_L16s",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.496,
"burstable": false,
"instanceType": "Standard_L32s",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.093,
"burstable": false,
"instanceType": "Standard_NV6",
"memory": 56.0,
"cpu": 6
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.185,
"burstable": false,
"instanceType": "Standard_NV12",
"memory": 112.0,
"cpu": 12
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.37,
"burstable": false,
"instanceType": "Standard_NV24",
"memory": 224.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.5365,
"burstable": false,
"instanceType": "Standard_M8ms",
"memory": 218.75,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.073,
"burstable": false,
"instanceType": "Standard_M16ms",
"memory": 437.5,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.07,
"burstable": false,
"instanceType": "Standard_ND6s",
"memory": 112.0,
"cpu": 6
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.14,
"burstable": false,
"instanceType": "Standard_ND12s",
"memory": 224.0,
"cpu": 12
},
{
"baseline": 1.0,
"generation": "current",
"price": 9.108,
"burstable": false,
"instanceType": "Standard_ND24rs",
"memory": 448.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 8.28,
"burstable": false,
"instanceType": "Standard_ND24s",
"memory": 448.0,
"cpu": 24
}
],
"North Europe": [
{
"baseline": 1.0,
"generation": "current",
"price": 0.066,
"burstable": false,
"instanceType": "Standard_D1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.132,
"burstable": false,
"instanceType": "Standard_D2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.263,
"burstable": false,
"instanceType": "Standard_D3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.527,
"burstable": false,
"instanceType": "Standard_D4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.053,
"burstable": false,
"instanceType": "Standard_D5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.185,
"burstable": false,
"instanceType": "Standard_D11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.371,
"burstable": false,
"instanceType": "Standard_D12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.741,
"burstable": false,
"instanceType": "Standard_D13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.482,
"burstable": false,
"instanceType": "Standard_D14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.132,
"burstable": false,
"instanceType": "Standard_D2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.263,
"burstable": false,
"instanceType": "Standard_D3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.527,
"burstable": false,
"instanceType": "Standard_D4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.053,
"burstable": false,
"instanceType": "Standard_D5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.185,
"burstable": false,
"instanceType": "Standard_D11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.371,
"burstable": false,
"instanceType": "Standard_D12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.741,
"burstable": false,
"instanceType": "Standard_D13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.482,
"burstable": false,
"instanceType": "Standard_D14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.057,
"burstable": false,
"instanceType": "Standard_F1",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.113,
"burstable": false,
"instanceType": "Standard_F2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.226,
"burstable": false,
"instanceType": "Standard_F4",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.452,
"burstable": false,
"instanceType": "Standard_F8",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.905,
"burstable": false,
"instanceType": "Standard_F16",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.018,
"burstable": false,
"instanceType": "Standard_A0",
"memory": 0.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.025,
"burstable": false,
"instanceType": "Standard_A1",
"memory": 1.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.12,
"burstable": false,
"instanceType": "Standard_A2",
"memory": 3.5,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.188,
"burstable": false,
"instanceType": "Standard_A3",
"memory": 7.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.248,
"burstable": false,
"instanceType": "Standard_A5",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.376,
"burstable": false,
"instanceType": "Standard_A4",
"memory": 14.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.496,
"burstable": false,
"instanceType": "Standard_A6",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.992,
"burstable": false,
"instanceType": "Standard_A7",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.041,
"burstable": false,
"instanceType": "Standard_A1_v2",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.139,
"burstable": false,
"instanceType": "Standard_A2m_v2",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.087,
"burstable": false,
"instanceType": "Standard_A2_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.291,
"burstable": false,
"instanceType": "Standard_A4m_v2",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.183,
"burstable": false,
"instanceType": "Standard_A4_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.611,
"burstable": false,
"instanceType": "Standard_A8m_v2",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.383,
"burstable": false,
"instanceType": "Standard_A8_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.107,
"burstable": false,
"instanceType": "Standard_D2_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.214,
"burstable": false,
"instanceType": "Standard_D4_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.428,
"burstable": false,
"instanceType": "Standard_D8_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.856,
"burstable": false,
"instanceType": "Standard_D16_v3",
"memory": 64.1,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.712,
"burstable": false,
"instanceType": "Standard_D32_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.424,
"burstable": false,
"instanceType": "Standard_D64_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.141,
"burstable": false,
"instanceType": "Standard_E2_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.282,
"burstable": false,
"instanceType": "Standard_E4_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.564,
"burstable": false,
"instanceType": "Standard_E8_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.128,
"burstable": false,
"instanceType": "Standard_E16_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.41,
"burstable": false,
"instanceType": "Standard_E20_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.256,
"burstable": false,
"instanceType": "Standard_E32_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.061,
"burstable": false,
"instanceType": "Standard_E64i_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.061,
"burstable": false,
"instanceType": "Standard_E64_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 0.2,
"generation": "current",
"price": 0.0227,
"burstable": true,
"instanceType": "Standard_B1ms",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 0.1,
"generation": "current",
"price": 0.0113,
"burstable": true,
"instanceType": "Standard_B1s",
"memory": 1.0,
"cpu": 1
},
{
"baseline": 0.6,
"generation": "current",
"price": 0.091,
"burstable": true,
"instanceType": "Standard_B2ms",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 0.4,
"generation": "current",
"price": 0.045,
"burstable": true,
"instanceType": "Standard_B2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 0.9,
"generation": "current",
"price": 0.182,
"burstable": true,
"instanceType": "Standard_B4ms",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.35,
"generation": "current",
"price": 0.364,
"burstable": true,
"instanceType": "Standard_B8ms",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.066,
"burstable": false,
"instanceType": "Standard_DS1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.132,
"burstable": false,
"instanceType": "Standard_DS2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.263,
"burstable": false,
"instanceType": "Standard_DS3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.527,
"burstable": false,
"instanceType": "Standard_DS4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.053,
"burstable": false,
"instanceType": "Standard_DS5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.185,
"burstable": false,
"instanceType": "Standard_DS11-1_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.185,
"burstable": false,
"instanceType": "Standard_DS11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.371,
"burstable": false,
"instanceType": "Standard_DS12-1_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.371,
"burstable": false,
"instanceType": "Standard_DS12-2_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.371,
"burstable": false,
"instanceType": "Standard_DS12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.741,
"burstable": false,
"instanceType": "Standard_DS13-2_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.741,
"burstable": false,
"instanceType": "Standard_DS13-4_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.741,
"burstable": false,
"instanceType": "Standard_DS13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.482,
"burstable": false,
"instanceType": "Standard_DS14-4_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.482,
"burstable": false,
"instanceType": "Standard_DS14-8_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.482,
"burstable": false,
"instanceType": "Standard_DS14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.853,
"burstable": false,
"instanceType": "Standard_DS15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.132,
"burstable": false,
"instanceType": "Standard_DS2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.263,
"burstable": false,
"instanceType": "Standard_DS3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.527,
"burstable": false,
"instanceType": "Standard_DS4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.053,
"burstable": false,
"instanceType": "Standard_DS5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.185,
"burstable": false,
"instanceType": "Standard_DS11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.371,
"burstable": false,
"instanceType": "Standard_DS12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.741,
"burstable": false,
"instanceType": "Standard_DS13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.482,
"burstable": false,
"instanceType": "Standard_DS14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.057,
"burstable": false,
"instanceType": "Standard_F1s",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.113,
"burstable": false,
"instanceType": "Standard_F2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.226,
"burstable": false,
"instanceType": "Standard_F4s",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.452,
"burstable": false,
"instanceType": "Standard_F8s",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.905,
"burstable": false,
"instanceType": "Standard_F16s",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.107,
"burstable": false,
"instanceType": "Standard_D2s_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.214,
"burstable": false,
"instanceType": "Standard_D4s_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.428,
"burstable": false,
"instanceType": "Standard_D8s_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.856,
"burstable": false,
"instanceType": "Standard_D16s_v3",
"memory": 64.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.712,
"burstable": false,
"instanceType": "Standard_D32s_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.424,
"burstable": false,
"instanceType": "Standard_D64s_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.141,
"burstable": false,
"instanceType": "Standard_E2s_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.282,
"burstable": false,
"instanceType": "Standard_E4s_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.564,
"burstable": false,
"instanceType": "Standard_E8s_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.128,
"burstable": false,
"instanceType": "Standard_E16s_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.41,
"burstable": false,
"instanceType": "Standard_E20s_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.256,
"burstable": false,
"instanceType": "Standard_E32s_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.061,
"burstable": false,
"instanceType": "Standard_E64is_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.061,
"burstable": false,
"instanceType": "Standard_E64s_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.853,
"burstable": false,
"instanceType": "Standard_D15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.073,
"burstable": false,
"instanceType": "Standard_D1",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.146,
"burstable": false,
"instanceType": "Standard_D2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.292,
"burstable": false,
"instanceType": "Standard_D3",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.584,
"burstable": false,
"instanceType": "Standard_D4",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.193,
"burstable": false,
"instanceType": "Standard_D11",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.386,
"burstable": false,
"instanceType": "Standard_D12",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.771,
"burstable": false,
"instanceType": "Standard_D13",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.542,
"burstable": false,
"instanceType": "Standard_D14",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.21,
"burstable": false,
"instanceType": "Standard_NV6",
"memory": 56.0,
"cpu": 6
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.42,
"burstable": false,
"instanceType": "Standard_NV12",
"memory": 112.0,
"cpu": 12
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.84,
"burstable": false,
"instanceType": "Standard_NV24",
"memory": 224.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.8438,
"burstable": false,
"instanceType": "Standard_M8ms",
"memory": 218.75,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.6876,
"burstable": false,
"instanceType": "Standard_M16ms",
"memory": 437.5,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.18903,
"burstable": false,
"instanceType": "Standard_M32ls",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 7.3752,
"burstable": false,
"instanceType": "Standard_M32ms",
"memory": 875.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.00477,
"burstable": false,
"instanceType": "Standard_M32ts",
"memory": 192.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 6.01065,
"burstable": false,
"instanceType": "Standard_M64ls",
"memory": 512.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 12.405,
"burstable": false,
"instanceType": "Standard_M64ms",
"memory": 1750.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 8.003,
"burstable": false,
"instanceType": "Standard_M64s",
"memory": 1000.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 32.0256,
"burstable": false,
"instanceType": "Standard_M128ms",
"memory": 3800.0,
"cpu": 128
},
{
"baseline": 1.0,
"generation": "current",
"price": 16.006,
"burstable": false,
"instanceType": "Standard_M128s",
"memory": 2000.0,
"cpu": 128
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.972,
"burstable": false,
"instanceType": "Standard_NC6",
"memory": 56.0,
"cpu": 6
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.944,
"burstable": false,
"instanceType": "Standard_NC12",
"memory": 112.0,
"cpu": 12
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.888,
"burstable": false,
"instanceType": "Standard_NC24",
"memory": 224.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.073,
"burstable": false,
"instanceType": "Standard_DS1",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.146,
"burstable": false,
"instanceType": "Standard_DS2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.292,
"burstable": false,
"instanceType": "Standard_DS3",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.584,
"burstable": false,
"instanceType": "Standard_DS4",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.193,
"burstable": false,
"instanceType": "Standard_DS11",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.386,
"burstable": false,
"instanceType": "Standard_DS12",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.771,
"burstable": false,
"instanceType": "Standard_DS13",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.542,
"burstable": false,
"instanceType": "Standard_DS14",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.096,
"burstable": false,
"instanceType": "Standard_F2s_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.192,
"burstable": false,
"instanceType": "Standard_F4s_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.384,
"burstable": false,
"instanceType": "Standard_F8s_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.768,
"burstable": false,
"instanceType": "Standard_F16s_v2",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.536,
"burstable": false,
"instanceType": "Standard_F32s_v2",
"memory": 64.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.072,
"burstable": false,
"instanceType": "Standard_F64s_v2",
"memory": 128.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.456,
"burstable": false,
"instanceType": "Standard_F72s_v2",
"memory": 144.0,
"cpu": 72
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.975,
"burstable": false,
"instanceType": "Standard_A8",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.95,
"burstable": false,
"instanceType": "Standard_A9",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.78,
"burstable": false,
"instanceType": "Standard_A10",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.56,
"burstable": false,
"instanceType": "Standard_A11",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.971,
"burstable": false,
"instanceType": "Standard_H8",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.941,
"burstable": false,
"instanceType": "Standard_H16",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.301,
"burstable": false,
"instanceType": "Standard_H8m",
"memory": 112.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.601,
"burstable": false,
"instanceType": "Standard_H16m",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.136,
"burstable": false,
"instanceType": "Standard_H16r",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.861,
"burstable": false,
"instanceType": "Standard_H16mr",
"memory": 224.0,
"cpu": 16
}
],
"North Central US": [
{
"baseline": 1.0,
"generation": "current",
"price": 0.02,
"burstable": false,
"instanceType": "Standard_A0",
"memory": 0.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.06,
"burstable": false,
"instanceType": "Standard_A1",
"memory": 1.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.085,
"burstable": false,
"instanceType": "Standard_A2",
"memory": 3.5,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.24,
"burstable": false,
"instanceType": "Standard_A3",
"memory": 7.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.25,
"burstable": false,
"instanceType": "Standard_A5",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.48,
"burstable": false,
"instanceType": "Standard_A4",
"memory": 14.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.5,
"burstable": false,
"instanceType": "Standard_A6",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.0,
"burstable": false,
"instanceType": "Standard_A7",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.073,
"burstable": false,
"instanceType": "Standard_D1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.146,
"burstable": false,
"instanceType": "Standard_D2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.293,
"burstable": false,
"instanceType": "Standard_D3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.585,
"burstable": false,
"instanceType": "Standard_D4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.17,
"burstable": false,
"instanceType": "Standard_D5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.185,
"burstable": false,
"instanceType": "Standard_D11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.37,
"burstable": false,
"instanceType": "Standard_D12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.741,
"burstable": false,
"instanceType": "Standard_D13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.482,
"burstable": false,
"instanceType": "Standard_D14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.852,
"burstable": false,
"instanceType": "Standard_D15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.146,
"burstable": false,
"instanceType": "Standard_D2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.293,
"burstable": false,
"instanceType": "Standard_D3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.585,
"burstable": false,
"instanceType": "Standard_D4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.17,
"burstable": false,
"instanceType": "Standard_D5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.185,
"burstable": false,
"instanceType": "Standard_D11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.37,
"burstable": false,
"instanceType": "Standard_D12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.741,
"burstable": false,
"instanceType": "Standard_D13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.482,
"burstable": false,
"instanceType": "Standard_D14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.05,
"burstable": false,
"instanceType": "Standard_F1",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.099,
"burstable": false,
"instanceType": "Standard_F2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.199,
"burstable": false,
"instanceType": "Standard_F4",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.398,
"burstable": false,
"instanceType": "Standard_F8",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.796,
"burstable": false,
"instanceType": "Standard_F16",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.043,
"burstable": false,
"instanceType": "Standard_A1_v2",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.129,
"burstable": false,
"instanceType": "Standard_A2m_v2",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.091,
"burstable": false,
"instanceType": "Standard_A2_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.27,
"burstable": false,
"instanceType": "Standard_A4m_v2",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.191,
"burstable": false,
"instanceType": "Standard_A4_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.568,
"burstable": false,
"instanceType": "Standard_A8m_v2",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.4,
"burstable": false,
"instanceType": "Standard_A8_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.1,
"burstable": false,
"instanceType": "Standard_D2_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.2,
"burstable": false,
"instanceType": "Standard_D4_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.4,
"burstable": false,
"instanceType": "Standard_D8_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.8,
"burstable": false,
"instanceType": "Standard_D16_v3",
"memory": 64.1,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.6,
"burstable": false,
"instanceType": "Standard_D32_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.2,
"burstable": false,
"instanceType": "Standard_D64_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.126,
"burstable": false,
"instanceType": "Standard_E2_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.252,
"burstable": false,
"instanceType": "Standard_E4_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.504,
"burstable": false,
"instanceType": "Standard_E8_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.008,
"burstable": false,
"instanceType": "Standard_E16_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.26,
"burstable": false,
"instanceType": "Standard_E20_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.016,
"burstable": false,
"instanceType": "Standard_E32_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.629,
"burstable": false,
"instanceType": "Standard_E64i_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.629,
"burstable": false,
"instanceType": "Standard_E64_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.904,
"burstable": false,
"instanceType": "Standard_H8",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.808,
"burstable": false,
"instanceType": "Standard_H16",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.211,
"burstable": false,
"instanceType": "Standard_H8m",
"memory": 112.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.423,
"burstable": false,
"instanceType": "Standard_H16m",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.989,
"burstable": false,
"instanceType": "Standard_H16r",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.665,
"burstable": false,
"instanceType": "Standard_H16mr",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 0.2,
"generation": "current",
"price": 0.0208,
"burstable": true,
"instanceType": "Standard_B1ms",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 0.1,
"generation": "current",
"price": 0.0104,
"burstable": true,
"instanceType": "Standard_B1s",
"memory": 1.0,
"cpu": 1
},
{
"baseline": 0.6,
"generation": "current",
"price": 0.0832,
"burstable": true,
"instanceType": "Standard_B2ms",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 0.4,
"generation": "current",
"price": 0.0416,
"burstable": true,
"instanceType": "Standard_B2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 0.9,
"generation": "current",
"price": 0.166,
"burstable": true,
"instanceType": "Standard_B4ms",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.35,
"generation": "current",
"price": 0.333,
"burstable": true,
"instanceType": "Standard_B8ms",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.073,
"burstable": false,
"instanceType": "Standard_DS1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.146,
"burstable": false,
"instanceType": "Standard_DS2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.293,
"burstable": false,
"instanceType": "Standard_DS3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.585,
"burstable": false,
"instanceType": "Standard_DS4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.17,
"burstable": false,
"instanceType": "Standard_DS5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.185,
"burstable": false,
"instanceType": "Standard_DS11-1_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.185,
"burstable": false,
"instanceType": "Standard_DS11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.37,
"burstable": false,
"instanceType": "Standard_DS12-1_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.37,
"burstable": false,
"instanceType": "Standard_DS12-2_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.37,
"burstable": false,
"instanceType": "Standard_DS12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.741,
"burstable": false,
"instanceType": "Standard_DS13-2_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.741,
"burstable": false,
"instanceType": "Standard_DS13-4_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.741,
"burstable": false,
"instanceType": "Standard_DS13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.482,
"burstable": false,
"instanceType": "Standard_DS14-4_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.482,
"burstable": false,
"instanceType": "Standard_DS14-8_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.482,
"burstable": false,
"instanceType": "Standard_DS14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.146,
"burstable": false,
"instanceType": "Standard_DS2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.293,
"burstable": false,
"instanceType": "Standard_DS3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.585,
"burstable": false,
"instanceType": "Standard_DS4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.17,
"burstable": false,
"instanceType": "Standard_DS5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.185,
"burstable": false,
"instanceType": "Standard_DS11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.37,
"burstable": false,
"instanceType": "Standard_DS12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.741,
"burstable": false,
"instanceType": "Standard_DS13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.482,
"burstable": false,
"instanceType": "Standard_DS14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.05,
"burstable": false,
"instanceType": "Standard_F1s",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.099,
"burstable": false,
"instanceType": "Standard_F2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.199,
"burstable": false,
"instanceType": "Standard_F4s",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.398,
"burstable": false,
"instanceType": "Standard_F8s",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.796,
"burstable": false,
"instanceType": "Standard_F16s",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.1,
"burstable": false,
"instanceType": "Standard_D2s_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.2,
"burstable": false,
"instanceType": "Standard_D4s_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.4,
"burstable": false,
"instanceType": "Standard_D8s_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.8,
"burstable": false,
"instanceType": "Standard_D16s_v3",
"memory": 64.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.6,
"burstable": false,
"instanceType": "Standard_D32s_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.2,
"burstable": false,
"instanceType": "Standard_D64s_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.126,
"burstable": false,
"instanceType": "Standard_E2s_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.252,
"burstable": false,
"instanceType": "Standard_E4s_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.504,
"burstable": false,
"instanceType": "Standard_E8s_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.008,
"burstable": false,
"instanceType": "Standard_E16s_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.26,
"burstable": false,
"instanceType": "Standard_E20s_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.016,
"burstable": false,
"instanceType": "Standard_E32s_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.629,
"burstable": false,
"instanceType": "Standard_E64is_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.629,
"burstable": false,
"instanceType": "Standard_E64s_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.077,
"burstable": false,
"instanceType": "Standard_D1",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.154,
"burstable": false,
"instanceType": "Standard_D2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.308,
"burstable": false,
"instanceType": "Standard_D3",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.616,
"burstable": false,
"instanceType": "Standard_D4",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.193,
"burstable": false,
"instanceType": "Standard_D11",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.386,
"burstable": false,
"instanceType": "Standard_D12",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.771,
"burstable": false,
"instanceType": "Standard_D13",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.542,
"burstable": false,
"instanceType": "Standard_D14",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.14,
"burstable": false,
"instanceType": "Standard_NV6",
"memory": 56.0,
"cpu": 6
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.28,
"burstable": false,
"instanceType": "Standard_NV12",
"memory": 112.0,
"cpu": 12
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.56,
"burstable": false,
"instanceType": "Standard_NV24",
"memory": 224.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.085,
"burstable": false,
"instanceType": "Standard_F2s_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.17,
"burstable": false,
"instanceType": "Standard_F4s_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.34,
"burstable": false,
"instanceType": "Standard_F8s_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.68,
"burstable": false,
"instanceType": "Standard_F16s_v2",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.36,
"burstable": false,
"instanceType": "Standard_F32s_v2",
"memory": 64.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.72,
"burstable": false,
"instanceType": "Standard_F64s_v2",
"memory": 128.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.06,
"burstable": false,
"instanceType": "Standard_F72s_v2",
"memory": 144.0,
"cpu": 72
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.9,
"burstable": false,
"instanceType": "Standard_NC6",
"memory": 56.0,
"cpu": 6
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.8,
"burstable": false,
"instanceType": "Standard_NC12",
"memory": 112.0,
"cpu": 12
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.6,
"burstable": false,
"instanceType": "Standard_NC24",
"memory": 224.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.852,
"burstable": false,
"instanceType": "Standard_DS15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.975,
"burstable": false,
"instanceType": "Standard_A8",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.95,
"burstable": false,
"instanceType": "Standard_A9",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.78,
"burstable": false,
"instanceType": "Standard_A10",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.56,
"burstable": false,
"instanceType": "Standard_A11",
"memory": 112.0,
"cpu": 16
}
],
"Japan East": [
{
"baseline": 1.0,
"generation": "current",
"price": 1.58,
"burstable": false,
"instanceType": "Standard_NV6",
"memory": 56.0,
"cpu": 6
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.16,
"burstable": false,
"instanceType": "Standard_NV12",
"memory": 112.0,
"cpu": 12
},
{
"baseline": 1.0,
"generation": "current",
"price": 6.32,
"burstable": false,
"instanceType": "Standard_NV24",
"memory": 224.0,
"cpu": 24
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.022,
"burstable": false,
"instanceType": "Standard_A0",
"memory": 0.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.032,
"burstable": false,
"instanceType": "Standard_A1",
"memory": 1.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.109,
"burstable": false,
"instanceType": "Standard_A2",
"memory": 3.5,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.324,
"burstable": false,
"instanceType": "Standard_A3",
"memory": 7.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.281,
"burstable": false,
"instanceType": "Standard_A5",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.648,
"burstable": false,
"instanceType": "Standard_A4",
"memory": 14.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.562,
"burstable": false,
"instanceType": "Standard_A6",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.124,
"burstable": false,
"instanceType": "Standard_A7",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.102,
"burstable": false,
"instanceType": "Standard_D1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.205,
"burstable": false,
"instanceType": "Standard_D2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.409,
"burstable": false,
"instanceType": "Standard_D3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.818,
"burstable": false,
"instanceType": "Standard_D4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.636,
"burstable": false,
"instanceType": "Standard_D5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.229,
"burstable": false,
"instanceType": "Standard_D11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.459,
"burstable": false,
"instanceType": "Standard_D12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.918,
"burstable": false,
"instanceType": "Standard_D13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.835,
"burstable": false,
"instanceType": "Standard_D14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.294,
"burstable": false,
"instanceType": "Standard_D15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.205,
"burstable": false,
"instanceType": "Standard_D2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.409,
"burstable": false,
"instanceType": "Standard_D3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.818,
"burstable": false,
"instanceType": "Standard_D4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.636,
"burstable": false,
"instanceType": "Standard_D5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.229,
"burstable": false,
"instanceType": "Standard_D11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.459,
"burstable": false,
"instanceType": "Standard_D12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.918,
"burstable": false,
"instanceType": "Standard_D13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.835,
"burstable": false,
"instanceType": "Standard_D14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.063,
"burstable": false,
"instanceType": "Standard_F1",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.126,
"burstable": false,
"instanceType": "Standard_F2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.252,
"burstable": false,
"instanceType": "Standard_F4",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.504,
"burstable": false,
"instanceType": "Standard_F8",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.008,
"burstable": false,
"instanceType": "Standard_F16",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.054,
"burstable": false,
"instanceType": "Standard_A1_v2",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.153,
"burstable": false,
"instanceType": "Standard_A2m_v2",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.113,
"burstable": false,
"instanceType": "Standard_A2_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.322,
"burstable": false,
"instanceType": "Standard_A4m_v2",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.238,
"burstable": false,
"instanceType": "Standard_A4_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.677,
"burstable": false,
"instanceType": "Standard_A8m_v2",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.5,
"burstable": false,
"instanceType": "Standard_A8_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.129,
"burstable": false,
"instanceType": "Standard_D2_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.258,
"burstable": false,
"instanceType": "Standard_D4_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.516,
"burstable": false,
"instanceType": "Standard_D8_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.032,
"burstable": false,
"instanceType": "Standard_D16_v3",
"memory": 64.1,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.064,
"burstable": false,
"instanceType": "Standard_D32_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.2279,
"burstable": false,
"instanceType": "Standard_M8ms",
"memory": 218.75,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.4559,
"burstable": false,
"instanceType": "Standard_M16ms",
"memory": 437.5,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.4476,
"burstable": false,
"instanceType": "Standard_M32ls",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 8.9117,
"burstable": false,
"instanceType": "Standard_M32ms",
"memory": 875.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.2484,
"burstable": false,
"instanceType": "Standard_M32ts",
"memory": 192.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 6.498,
"burstable": false,
"instanceType": "Standard_M64ls",
"memory": 512.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 14.99,
"burstable": false,
"instanceType": "Standard_M64ms",
"memory": 1750.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 9.671,
"burstable": false,
"instanceType": "Standard_M64s",
"memory": 1000.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 38.701,
"burstable": false,
"instanceType": "Standard_M128ms",
"memory": 3800.0,
"cpu": 128
},
{
"baseline": 1.0,
"generation": "current",
"price": 19.342,
"burstable": false,
"instanceType": "Standard_M128s",
"memory": 2000.0,
"cpu": 128
},
{
"baseline": 0.2,
"generation": "current",
"price": 0.0272,
"burstable": true,
"instanceType": "Standard_B1ms",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 0.1,
"generation": "current",
"price": 0.0136,
"burstable": true,
"instanceType": "Standard_B1s",
"memory": 1.0,
"cpu": 1
},
{
"baseline": 0.6,
"generation": "current",
"price": 0.109,
"burstable": true,
"instanceType": "Standard_B2ms",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 0.4,
"generation": "current",
"price": 0.0544,
"burstable": true,
"instanceType": "Standard_B2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 0.9,
"generation": "current",
"price": 0.218,
"burstable": true,
"instanceType": "Standard_B4ms",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.35,
"generation": "current",
"price": 0.435,
"burstable": true,
"instanceType": "Standard_B8ms",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.102,
"burstable": false,
"instanceType": "Standard_DS1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.205,
"burstable": false,
"instanceType": "Standard_DS2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.409,
"burstable": false,
"instanceType": "Standard_DS3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.818,
"burstable": false,
"instanceType": "Standard_DS4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.636,
"burstable": false,
"instanceType": "Standard_DS5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.229,
"burstable": false,
"instanceType": "Standard_DS11-1_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.229,
"burstable": false,
"instanceType": "Standard_DS11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.459,
"burstable": false,
"instanceType": "Standard_DS12-1_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.459,
"burstable": false,
"instanceType": "Standard_DS12-2_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.459,
"burstable": false,
"instanceType": "Standard_DS12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.918,
"burstable": false,
"instanceType": "Standard_DS13-2_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.918,
"burstable": false,
"instanceType": "Standard_DS13-4_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.918,
"burstable": false,
"instanceType": "Standard_DS13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.835,
"burstable": false,
"instanceType": "Standard_DS14-4_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.835,
"burstable": false,
"instanceType": "Standard_DS14-8_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.835,
"burstable": false,
"instanceType": "Standard_DS14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.294,
"burstable": false,
"instanceType": "Standard_DS15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.205,
"burstable": false,
"instanceType": "Standard_DS2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.409,
"burstable": false,
"instanceType": "Standard_DS3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.818,
"burstable": false,
"instanceType": "Standard_DS4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.636,
"burstable": false,
"instanceType": "Standard_DS5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.229,
"burstable": false,
"instanceType": "Standard_DS11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.459,
"burstable": false,
"instanceType": "Standard_DS12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.918,
"burstable": false,
"instanceType": "Standard_DS13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.835,
"burstable": false,
"instanceType": "Standard_DS14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.063,
"burstable": false,
"instanceType": "Standard_F1s",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.126,
"burstable": false,
"instanceType": "Standard_F2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.252,
"burstable": false,
"instanceType": "Standard_F4s",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.504,
"burstable": false,
"instanceType": "Standard_F8s",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.008,
"burstable": false,
"instanceType": "Standard_F16s",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.129,
"burstable": false,
"instanceType": "Standard_D2s_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.258,
"burstable": false,
"instanceType": "Standard_D4s_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.516,
"burstable": false,
"instanceType": "Standard_D8s_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.032,
"burstable": false,
"instanceType": "Standard_D16s_v3",
"memory": 64.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.064,
"burstable": false,
"instanceType": "Standard_D32s_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.145,
"burstable": false,
"instanceType": "Standard_H8",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.291,
"burstable": false,
"instanceType": "Standard_H16",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.535,
"burstable": false,
"instanceType": "Standard_H8m",
"memory": 112.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.07,
"burstable": false,
"instanceType": "Standard_H16m",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.52,
"burstable": false,
"instanceType": "Standard_H16r",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.377,
"burstable": false,
"instanceType": "Standard_H16mr",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.107,
"burstable": false,
"instanceType": "Standard_F2s_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.214,
"burstable": false,
"instanceType": "Standard_F4s_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.428,
"burstable": false,
"instanceType": "Standard_F8s_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.856,
"burstable": false,
"instanceType": "Standard_F16s_v2",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.712,
"burstable": false,
"instanceType": "Standard_F32s_v2",
"memory": 64.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.424,
"burstable": false,
"instanceType": "Standard_F64s_v2",
"memory": 128.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 3.852,
"burstable": false,
"instanceType": "Standard_F72s_v2",
"memory": 144.0,
"cpu": 72
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.128,
"burstable": false,
"instanceType": "Standard_D64_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.128,
"burstable": false,
"instanceType": "Standard_D64s_v3",
"memory": 256.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.16,
"burstable": false,
"instanceType": "Standard_E2_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.32,
"burstable": false,
"instanceType": "Standard_E4_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.64,
"burstable": false,
"instanceType": "Standard_E8_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.28,
"burstable": false,
"instanceType": "Standard_E16_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.6,
"burstable": false,
"instanceType": "Standard_E20_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.56,
"burstable": false,
"instanceType": "Standard_E32_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.376,
"burstable": false,
"instanceType": "Standard_E64i_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.376,
"burstable": false,
"instanceType": "Standard_E64_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.16,
"burstable": false,
"instanceType": "Standard_E2s_v3",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.32,
"burstable": false,
"instanceType": "Standard_E4s_v3",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.64,
"burstable": false,
"instanceType": "Standard_E8s_v3",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.28,
"burstable": false,
"instanceType": "Standard_E16s_v3",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.6,
"burstable": false,
"instanceType": "Standard_E20s_v3",
"memory": 160.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.56,
"burstable": false,
"instanceType": "Standard_E32s_v3",
"memory": 256.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.376,
"burstable": false,
"instanceType": "Standard_E64is_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.376,
"burstable": false,
"instanceType": "Standard_E64s_v3",
"memory": 432.0,
"cpu": 64
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.11,
"burstable": false,
"instanceType": "Standard_D1",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.221,
"burstable": false,
"instanceType": "Standard_D2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.442,
"burstable": false,
"instanceType": "Standard_D3",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.883,
"burstable": false,
"instanceType": "Standard_D4",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.242,
"burstable": false,
"instanceType": "Standard_D11",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.483,
"burstable": false,
"instanceType": "Standard_D12",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.966,
"burstable": false,
"instanceType": "Standard_D13",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.932,
"burstable": false,
"instanceType": "Standard_D14",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.11,
"burstable": false,
"instanceType": "Standard_DS1",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.221,
"burstable": false,
"instanceType": "Standard_DS2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.442,
"burstable": false,
"instanceType": "Standard_DS3",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.883,
"burstable": false,
"instanceType": "Standard_DS4",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.242,
"burstable": false,
"instanceType": "Standard_DS11",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.483,
"burstable": false,
"instanceType": "Standard_DS12",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.966,
"burstable": false,
"instanceType": "Standard_DS13",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.932,
"burstable": false,
"instanceType": "Standard_DS14",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.576,
"burstable": false,
"instanceType": "Standard_G1",
"memory": 28.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.151,
"burstable": false,
"instanceType": "Standard_G2",
"memory": 56.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.302,
"burstable": false,
"instanceType": "Standard_G3",
"memory": 112.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.602,
"burstable": false,
"instanceType": "Standard_G4",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 9.205,
"burstable": false,
"instanceType": "Standard_G5",
"memory": 448.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.576,
"burstable": false,
"instanceType": "Standard_GS1",
"memory": 28.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.151,
"burstable": false,
"instanceType": "Standard_GS2",
"memory": 56.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.302,
"burstable": false,
"instanceType": "Standard_GS3",
"memory": 112.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.602,
"burstable": false,
"instanceType": "Standard_GS4",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.602,
"burstable": false,
"instanceType": "Standard_GS4-4",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 4.602,
"burstable": false,
"instanceType": "Standard_GS4-8",
"memory": 224.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 9.205,
"burstable": false,
"instanceType": "Standard_GS5",
"memory": 448.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 9.205,
"burstable": false,
"instanceType": "Standard_GS5-8",
"memory": 448.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 9.205,
"burstable": false,
"instanceType": "Standard_GS5-16",
"memory": 448.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.366,
"burstable": false,
"instanceType": "Standard_L4s",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.732,
"burstable": false,
"instanceType": "Standard_L8s",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.464,
"burstable": false,
"instanceType": "Standard_L16s",
"memory": 128.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 2.928,
"burstable": false,
"instanceType": "Standard_L32s",
"memory": 256.0,
"cpu": 32
}
],
"West Central US": [
{
"baseline": 1.0,
"generation": "current",
"price": 0.064,
"burstable": false,
"instanceType": "Standard_DS1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.127,
"burstable": false,
"instanceType": "Standard_DS2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.254,
"burstable": false,
"instanceType": "Standard_DS3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.509,
"burstable": false,
"instanceType": "Standard_DS4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.017,
"burstable": false,
"instanceType": "Standard_DS5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.166,
"burstable": false,
"instanceType": "Standard_DS11-1_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.166,
"burstable": false,
"instanceType": "Standard_DS11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.332,
"burstable": false,
"instanceType": "Standard_DS12-1_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.332,
"burstable": false,
"instanceType": "Standard_DS12-2_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.332,
"burstable": false,
"instanceType": "Standard_DS12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.665,
"burstable": false,
"instanceType": "Standard_DS13-2_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.665,
"burstable": false,
"instanceType": "Standard_DS13-4_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.665,
"burstable": false,
"instanceType": "Standard_DS13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.33,
"burstable": false,
"instanceType": "Standard_DS14-4_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.33,
"burstable": false,
"instanceType": "Standard_DS14-8_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.33,
"burstable": false,
"instanceType": "Standard_DS14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.662,
"burstable": false,
"instanceType": "Standard_DS15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.127,
"burstable": false,
"instanceType": "Standard_DS2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.254,
"burstable": false,
"instanceType": "Standard_DS3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.509,
"burstable": false,
"instanceType": "Standard_DS4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.017,
"burstable": false,
"instanceType": "Standard_DS5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.166,
"burstable": false,
"instanceType": "Standard_DS11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.332,
"burstable": false,
"instanceType": "Standard_DS12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.665,
"burstable": false,
"instanceType": "Standard_DS13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.33,
"burstable": false,
"instanceType": "Standard_DS14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.055,
"burstable": false,
"instanceType": "Standard_F1s",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.109,
"burstable": false,
"instanceType": "Standard_F2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.219,
"burstable": false,
"instanceType": "Standard_F4s",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.438,
"burstable": false,
"instanceType": "Standard_F8s",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.875,
"burstable": false,
"instanceType": "Standard_F16s",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 0.2,
"generation": "current",
"price": 0.025,
"burstable": true,
"instanceType": "Standard_B1ms",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 0.1,
"generation": "current",
"price": 0.013,
"burstable": true,
"instanceType": "Standard_B1s",
"memory": 1.0,
"cpu": 1
},
{
"baseline": 0.6,
"generation": "current",
"price": 0.0998,
"burstable": true,
"instanceType": "Standard_B2ms",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 0.4,
"generation": "current",
"price": 0.0499,
"burstable": true,
"instanceType": "Standard_B2s",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 0.9,
"generation": "current",
"price": 0.2,
"burstable": true,
"instanceType": "Standard_B4ms",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.35,
"generation": "current",
"price": 0.399,
"burstable": true,
"instanceType": "Standard_B8ms",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.11,
"burstable": false,
"instanceType": "Standard_D2s_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.22,
"burstable": false,
"instanceType": "Standard_D4s_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.44,
"burstable": false,
"instanceType": "Standard_D8s_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.88,
"burstable": false,
"instanceType": "Standard_D16s_v3",
"memory": 64.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.76,
"burstable": false,
"instanceType": "Standard_D32s_v3",
"memory": 128.0,
"cpu": 32
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.018,
"burstable": false,
"instanceType": "Standard_A0",
"memory": 0.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.051,
"burstable": false,
"instanceType": "Standard_A1",
"memory": 1.75,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.101,
"burstable": false,
"instanceType": "Standard_A2",
"memory": 3.5,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.176,
"burstable": false,
"instanceType": "Standard_A3",
"memory": 7.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.22,
"burstable": false,
"instanceType": "Standard_A5",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.352,
"burstable": false,
"instanceType": "Standard_A4",
"memory": 14.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.44,
"burstable": false,
"instanceType": "Standard_A6",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.88,
"burstable": false,
"instanceType": "Standard_A7",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.064,
"burstable": false,
"instanceType": "Standard_D1_v2",
"memory": 3.5,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.127,
"burstable": false,
"instanceType": "Standard_D2_v2",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.254,
"burstable": false,
"instanceType": "Standard_D3_v2",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.44,
"burstable": false,
"instanceType": "Standard_D4_v2",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.017,
"burstable": false,
"instanceType": "Standard_D5_v2",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.166,
"burstable": false,
"instanceType": "Standard_D11_v2",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.332,
"burstable": false,
"instanceType": "Standard_D12_v2",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.665,
"burstable": false,
"instanceType": "Standard_D13_v2",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.17,
"burstable": false,
"instanceType": "Standard_D14_v2",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.662,
"burstable": false,
"instanceType": "Standard_D15_v2",
"memory": 140.0,
"cpu": 20
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.127,
"burstable": false,
"instanceType": "Standard_D2_v2_Promo",
"memory": 7.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.254,
"burstable": false,
"instanceType": "Standard_D3_v2_Promo",
"memory": 14.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.44,
"burstable": false,
"instanceType": "Standard_D4_v2_Promo",
"memory": 28.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.017,
"burstable": false,
"instanceType": "Standard_D5_v2_Promo",
"memory": 56.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.166,
"burstable": false,
"instanceType": "Standard_D11_v2_Promo",
"memory": 14.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.332,
"burstable": false,
"instanceType": "Standard_D12_v2_Promo",
"memory": 28.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.665,
"burstable": false,
"instanceType": "Standard_D13_v2_Promo",
"memory": 56.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.17,
"burstable": false,
"instanceType": "Standard_D14_v2_Promo",
"memory": 112.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.055,
"burstable": false,
"instanceType": "Standard_F1",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.109,
"burstable": false,
"instanceType": "Standard_F2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.219,
"burstable": false,
"instanceType": "Standard_F4",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.438,
"burstable": false,
"instanceType": "Standard_F8",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.875,
"burstable": false,
"instanceType": "Standard_F16",
"memory": 32.0,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.04,
"burstable": false,
"instanceType": "Standard_A1_v2",
"memory": 2.0,
"cpu": 1
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.119,
"burstable": false,
"instanceType": "Standard_A2m_v2",
"memory": 16.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.083,
"burstable": false,
"instanceType": "Standard_A2_v2",
"memory": 4.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.249,
"burstable": false,
"instanceType": "Standard_A4m_v2",
"memory": 32.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.175,
"burstable": false,
"instanceType": "Standard_A4_v2",
"memory": 8.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.524,
"burstable": false,
"instanceType": "Standard_A8m_v2",
"memory": 64.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.367,
"burstable": false,
"instanceType": "Standard_A8_v2",
"memory": 16.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.11,
"burstable": false,
"instanceType": "Standard_D2_v3",
"memory": 8.0,
"cpu": 2
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.22,
"burstable": false,
"instanceType": "Standard_D4_v3",
"memory": 16.0,
"cpu": 4
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.44,
"burstable": false,
"instanceType": "Standard_D8_v3",
"memory": 32.0,
"cpu": 8
},
{
"baseline": 1.0,
"generation": "current",
"price": 0.88,
"burstable": false,
"instanceType": "Standard_D16_v3",
"memory": 64.1,
"cpu": 16
},
{
"baseline": 1.0,
"generation": "current",
"price": 1.76,
"burstable": false,
"instanceType": "Standard_D32_v3",
"memory": 128.0,
"cpu": 32
}
]
}
` | pkg/util/instanceselector/azure_instance_data.go | 0.708616 | 0.547827 | azure_instance_data.go | starcoder |
package sqi
import (
"math"
"reflect"
)
// interfacesEqual() answers true if both interfaces are the same underlying data.
// If strict is true, numbers must be of the same type. If it's false,
// numbers will attempt to convert for a comparison.
func interfacesEqual(a, b interface{}, strict bool) (bool, error) {
if a == nil && b == nil {
return true, nil
} else if a == nil || b == nil {
return false, nil
}
switch at := a.(type) {
case bool:
if bt, ok := b.(bool); ok {
return at == bt, nil
}
return false, newMismatchError("types " + reflect.TypeOf(a).Name() + " and " + reflect.TypeOf(b).Name())
case string:
if bt, ok := b.(string); ok {
return at == bt, nil
}
return false, newMismatchError("types " + reflect.TypeOf(a).Name() + " and " + reflect.TypeOf(b).Name())
case int:
if bt, ok := b.(int); ok {
return at == bt, nil
}
if !strict {
return numbersEqual(float64(at), b)
}
return false, newMismatchError("types " + reflect.TypeOf(a).Name() + " and " + reflect.TypeOf(b).Name())
case float32:
if bt, ok := b.(float32); ok {
return float64Equal(float64(at), float64(bt)), nil
}
if !strict {
return numbersEqual(float64(at), b)
}
return false, newMismatchError("types " + reflect.TypeOf(a).Name() + " and " + reflect.TypeOf(b).Name())
case float64:
if bt, ok := b.(float64); ok {
return float64Equal(at, bt), nil
}
if !strict {
return numbersEqual(at, b)
}
return false, newMismatchError("types " + reflect.TypeOf(a).Name() + " and " + reflect.TypeOf(b).Name())
default:
return false, newUnhandledError("type " + reflect.TypeOf(a).Name())
}
}
// ------------------------------------------------------------
// MISC
func numbersEqual(a float64, b interface{}) (bool, error) {
switch bt := b.(type) {
case int:
return float64Equal(a, float64(bt)), nil
case float32:
return float64Equal(a, float64(bt)), nil
case float64:
return float64Equal(a, bt), nil
default:
return false, newUnhandledError("type " + reflect.TypeOf(a).Name())
}
}
func float64Equal(a, b float64) bool {
return math.Abs(a-b) <= float64EqualityThreshold
}
// ------------------------------------------------------------
// CONST and VAR
const (
float64EqualityThreshold = 1e-9
) | compare.go | 0.601594 | 0.52543 | compare.go | starcoder |
package vector
import (
"fmt"
"strings"
)
const (
bits uint32 = 3 // will produce nodes with degree 2^3 = 8
degree uint32 = 1 << bits
mask uint32 = degree - 1
)
type props struct {
bits uint32 // number of bits to use per level
degree uint32 // degree is always 2^bits
mask uint32 // mask is degree - 1, i.e. a bit pattern with trailing 1s of length 'bits'
shift uint32 // we do not store h(v), but rather bits*h(v)
}
func (p props) init() props {
if p.bits > 0 {
return p
}
return props{
bits: bits,
degree: degree,
mask: mask,
}
}
func (p props) withShift(shift uint32) props {
p.shift = shift
return p
}
type vnode[T any] struct {
children []*vnode[T]
leafs []T
}
func emptyNode[T any](k uint32) *vnode[T] {
return &vnode[T]{
children: make([]*vnode[T], int(k)),
}
}
func newLeaf[T any](tail []T) *vnode[T] {
l := make([]T, len(tail))
if tail != nil {
copy(l, tail)
}
return &vnode[T]{leafs: l}
}
func (node vnode[T]) clone(extend bool) *vnode[T] {
ext := 0
if extend {
ext = 1
}
n := &vnode[T]{}
if node.leafs != nil {
n.leafs = make([]T, len(node.leafs), len(node.leafs)+ext)
copy(n.leafs, node.leafs)
}
if node.children != nil {
n.children = make([]*vnode[T], len(node.children), len(node.children)+ext)
copy(n.children, node.children)
}
return n
}
func cloneTail[T any](tail []T, l int) []T {
var newTail []T
newTail = make([]T, l)
if tail != nil {
copy(newTail, tail[:min(l, len(tail))])
}
return newTail
}
func newPath[T any](levels, bits, k uint32, tail []T) *vnode[T] {
//assertThat(levels > 0, "levels must be > 0 to create path, is %d", levels)
// topNode := emptyNode[T](k)
// topNode.children[0] =
topNode := newLeaf(tail)
tracer().Debugf("pushing down tail %v", tail)
tracer().Debugf("levels = %d, bits = %d", levels, bits)
for level := levels; level > 0; level -= bits {
tracer().Debugf("creating intermediate node at level %d", level)
tracer().Debugf("level = %d, bits = %d", level, bits)
newTop := emptyNode[T](k)
newTop.children[0] = topNode
topNode = newTop
}
return topNode
}
func (node vnode[T]) String() string {
b := strings.Builder{}
b.WriteByte('[')
if node.leafs != nil {
for i, l := range node.leafs {
if i > 0 {
b.WriteByte(',')
}
b.WriteString(fmt.Sprintf("%v", l))
}
} else {
for i, c := range node.children {
if i > 0 {
b.WriteByte(',')
}
if c == nil {
b.WriteByte('_')
} else {
b.WriteString("▪︎")
}
}
}
b.WriteByte(']')
return b.String()
}
// ---------------------------------------------------------------------------
func assertThat(that bool, msg string, msgargs ...interface{}) {
if !that {
msg = fmt.Sprintf("persistent.vector: "+msg, msgargs...)
panic(msg)
}
}
func min(a, b int) int {
if a < b {
return a
}
return b
} | persistent/vector/internals.go | 0.520253 | 0.444263 | internals.go | starcoder |
package encoding
import (
"reflect"
)
// IsNiler is an interface implemented by an object with a nil value that may
// differ from Go's default nil value. This is used in encoding/map with the
// "omitnil" struct tag to give fields a chance to specify when they should be
// omitted due to containing a nil value.
type IsNiler interface {
IsNil() bool
}
// IsNil returns true if the given value `v` is equivalent to nil,
// either because it is an `IsNiler` and `v.IsNil()` returns `true`, or it is a
// channel, function variable, interface, map, pointer, or slice whose value is
// the associated `nil`.
func IsNil(v interface{}) bool {
if v == nil {
return true
}
if n, ok := v.(IsNiler); ok {
return n.IsNil()
}
rv := reflect.ValueOf(v)
switch rv.Kind() {
case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
return rv.IsNil()
}
return false
}
// IsValueNil returns true if the given reflect.Value `v` is equivalent to nil,
// either because it is an `IsNiler` and `v.IsNil()` returns `true`, or it is a
// channel, function variable, interface, map, pointer, or slice whose value is
// the associated `nil`.
func IsValueNil(v reflect.Value) bool {
if n, ok := v.Interface().(IsNiler); ok {
return n.IsNil()
}
switch v.Kind() {
case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
return v.IsNil()
}
return false
}
// IsZeroer is an interface implemented by an object with a zero value that may
// differ from Go's default zero value. This is used in encoding/map with the
// "omitzero" struct tag to give fields a chance to specify when they should be
// omitted due to containing a zero value.
type IsZeroer interface {
IsZero() bool
}
// IsZero returns true if the given value `v` is that type's zero value, either
// because it is an `IsZeroer` and `v.IsZero()` returns `true`, or if it is
// equal to that type's default zero value.
func IsZero(v interface{}) bool {
if v == nil {
return true
}
if z, ok := v.(IsZeroer); ok {
return z.IsZero()
}
rv := reflect.ValueOf(v)
switch rv.Kind() {
// We consider an Array to be of Zero Value when all of its elements are
// that type's Zero Value.
case reflect.Array:
ret := true
for i := 0; i < rv.Len(); i++ {
if !IsValueZero(rv.Index(i)) {
ret = false
break
}
}
return ret
case reflect.Struct:
ret := true
for i := 0; i < rv.NumField(); i++ {
if !IsValueZero(rv.Field(i)) {
ret = false
break
}
}
return ret
case reflect.Map, reflect.Slice, reflect.String:
return rv.Len() == 0
case reflect.Bool:
return !rv.Bool()
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return rv.Int() == 0
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
return rv.Uint() == 0
case reflect.Float32, reflect.Float64:
return rv.Float() == 0
case reflect.Complex64, reflect.Complex128:
return rv == reflect.Zero(reflect.TypeOf(rv)).Interface()
case reflect.Chan, reflect.Func, reflect.Interface, reflect.Ptr:
return rv.IsNil()
}
return false
}
func IsValueZero(v reflect.Value) bool {
if z, ok := v.Interface().(IsZeroer); ok {
return z.IsZero()
}
switch v.Kind() {
// We consider an Array to be of Zero Value when all of its elements are
// that type's Zero Value.
case reflect.Array:
ret := true
for i := 0; i < v.Len(); i++ {
if !IsValueZero(v.Index(i)) {
ret = false
break
}
}
return ret
case reflect.Struct:
ret := true
for i := 0; i < v.NumField(); i++ {
if !IsValueZero(v.Field(i)) {
ret = false
break
}
}
return ret
case reflect.Map, reflect.Slice, reflect.String:
return v.Len() == 0
case reflect.Bool:
return !v.Bool()
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return v.Int() == 0
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
return v.Uint() == 0
case reflect.Float32, reflect.Float64:
return v.Float() == 0
case reflect.Complex64, reflect.Complex128:
return v == reflect.Zero(reflect.TypeOf(v)).Interface()
case reflect.Chan, reflect.Func, reflect.Interface, reflect.Ptr:
return v.IsNil()
}
return false
} | encoding.go | 0.820613 | 0.55447 | encoding.go | starcoder |
package base
import (
"encoding/csv"
"fmt"
"os"
"sort"
"strconv"
"strings"
)
// BaseModel contains basic attributes and methods to get going
type BaseModel struct {
FileName string
ClassIndex int
Data [][]float64
categoricalAttributes map[int]map[string]float64
AttributeNormalisation bool
}
// GetClassString returns the category of the given normalised value
// returns zero string if not found
func (model *BaseModel) GetClassString(value float64) string {
categories := model.categoricalAttributes[model.ClassIndex]
for k, v := range categories {
if v == value {
return k
}
}
return ""
}
//setCategoricalAttributeIndex will initiate the given index as category
func (model *BaseModel) setCategoricalAttributeIndex(index int) {
if model.categoricalAttributes == nil {
model.categoricalAttributes = make(map[int]map[string]float64)
}
_, ok := model.categoricalAttributes[index]
if ok {
return
}
model.categoricalAttributes[index] = make(map[string]float64)
}
// checkForCategoricalAttributes will check if the any attribute in the given data is category
// do that we can normalise the data if needed
func (model *BaseModel) checkForCategoricalAttributes(instances [][]string) {
// we try to convert the attributes in the first row to float64
// any failures is considered categorical
// normalisation is must if one category is found
// we will not categorise class for obvious reasons
instance := instances[0]
indexes := len(instance)
for i := 0; i < indexes; i++ {
if i == model.ClassIndex {
model.setCategoricalAttributeIndex(i)
continue
}
_, err := strconv.ParseFloat(instance[i], 64)
if err == nil {
continue
}
// must be a categorical value
model.setCategoricalAttributeIndex(i)
model.AttributeNormalisation = true
}
}
// updateClassIndex will update the class index if default
func (model *BaseModel) updateClassIndex(data []string) {
if model.ClassIndex == -1 {
model.ClassIndex = len(data) - 1
}
fmt.Printf("class index is set at %v\n", model.ClassIndex)
}
// assignCategoryValues will assign a value for each category for a given attribute
func (model *BaseModel) assignCategoryValues(instances [][]string) {
for index, categories := range model.categoricalAttributes {
var value float64
for _, instance := range instances {
category := instance[index]
_, ok := categories[category]
if ok {
continue
}
categories[category] = value
value += 1
}
}
}
// normaliseData normalise the data set that is loaded
func (model *BaseModel) normaliseData(instances [][]string) {
// update class index
model.updateClassIndex(instances[0])
// look for categories
model.checkForCategoricalAttributes(instances)
//convert all categorical values to respective floats
model.assignCategoryValues(instances)
// instantiate normalisedSet
outerIndex := len(instances)
innerIndex := len(instances[0])
normaliseSet := make([][]float64, outerIndex)
// convert to float64
for index, instance := range instances {
normaliseSet[index] = make([]float64, innerIndex)
for i, k := range instance {
categories, ok := model.categoricalAttributes[i]
if ok {
normaliseSet[index][i] = categories[k]
continue
}
value, _ := strconv.ParseFloat(k, 64)
normaliseSet[index][i] = value
}
}
// do normalisation if required
if !model.AttributeNormalisation {
model.Data = normaliseSet
return
}
for i := 0; i < innerIndex; i++ {
if i == model.ClassIndex {
continue
}
var column sort.Float64Slice
for _, instance := range normaliseSet {
column = append(column, instance[i])
}
sort.Sort(column)
min := column[0]
den := column[len(column)-1] - min
for _, instance := range normaliseSet {
num := instance[i] - min
instance[i] = num / den
}
}
model.Data = normaliseSet
}
// PrepareModel will load the data from the file given and
// Normalise the data if required
func (model *BaseModel) PrepareModel() error {
fmt.Printf("loading data from '%v'...\n", model.FileName)
fh, err := os.Open(model.FileName)
if err != nil {
return err
}
rows, err := csv.NewReader(fh).ReadAll()
if err != nil {
return err
}
var originalSet [][]string
for _, row := range rows {
for i := range row {
row[i] = strings.TrimSpace(row[i])
}
originalSet = append(originalSet, row)
}
fmt.Printf("loaded %v rows...\n", len(originalSet))
fmt.Println("normalising data...")
model.normaliseData(originalSet)
fmt.Println("normalisation done...")
return nil
} | base/models.go | 0.697094 | 0.440469 | models.go | starcoder |
package kinc
import "unsafe"
type ComputeConstantLocation struct {
ref *kinc_compute_constant_location
}
type ConstantLocation struct {
ref *kinc_g4_constant_location
}
func ComputeSetBool(location ComputeConstantLocation, value bool) {
kinc_compute_set_bool(*location.ref, value)
}
func ComputeSetInt(location ComputeConstantLocation, value int32) {
kinc_compute_set_int(*location.ref, value)
}
func ComputeSetFloat(location ComputeConstantLocation, value float32) {
kinc_compute_set_float(*location.ref, value)
}
func ComputeSetFloat2(location ComputeConstantLocation, value float32, value1 float32) {
kinc_compute_set_float2(*location.ref, value, value1)
}
func ComputeSetFloat3(location ComputeConstantLocation, value float32, value1 float32, value2 float32) {
kinc_compute_set_float3(*location.ref, value, value1, value2)
}
func ComputeSetFloat4(location ComputeConstantLocation, value float32, value1 float32, value2 float32, value3 float32) {
kinc_compute_set_float4(*location.ref, value, value1, value2, value3)
}
func ComputeSetFloats(location ComputeConstantLocation, value []float32, count int32) {
kinc_compute_set_floats(*location.ref, value, count)
}
func ComputeSetMatrix4(location ComputeConstantLocation, value *Matrix4x4) {
kinc_compute_set_matrix4(*location.ref, value.ref)
}
func ComputeSetMatrix3(location ComputeConstantLocation, value *Matrix3x3) {
kinc_compute_set_matrix3(*location.ref, value.ref)
}
type ComputeShader struct {
ref *kinc_compute_shader
}
type ComputeTextureUnit struct {
ref *kinc_compute_texture_unit
}
type ComputeAccess kinc_compute_access
const (
COMPUTE_ACCESS_READ ComputeAccess = 0
COMPUTE_ACCESS_WRITE ComputeAccess = 1
COMPUTE_ACCESS_READ_WRITE ComputeAccess = 2
)
func ComputeSetTexture(unit ComputeTextureUnit, texture *Texture, access ComputeAccess) {
kinc_compute_set_texture(*unit.ref, texture.ref, kinc_compute_access(access))
}
func ComputeSetSampledTexture(unit ComputeTextureUnit, texture *Texture) {
kinc_compute_set_sampled_texture(*unit.ref, texture.ref)
}
func ComputSetSampledRenderTarget(unit ComputeTextureUnit, target *RenderTarget) {
kinc_compute_set_sampled_render_target(*unit.ref, target.ref)
}
func ComputSetSampledDepthFromRenderTarget(unit ComputeTextureUnit, target *RenderTarget) {
kinc_compute_set_sampled_depth_from_render_target(*unit.ref, target.ref)
}
func ComputeSetTextureAddressing(unit ComputeTextureUnit, dir TextureDirection, addressing TextureAddressing) {
kinc_compute_set_texture_addressing(*unit.ref, kinc_g4_texture_direction(dir), kinc_g4_texture_addressing(addressing))
}
func ComputeSetTexture3DAddressing(unit ComputeTextureUnit, dir TextureDirection, addressing TextureAddressing) {
kinc_compute_set_texture3d_addressing(*unit.ref, kinc_g4_texture_direction(dir), kinc_g4_texture_addressing(addressing))
}
func ComputeSetTextureMagnificationFilter(unit ComputeTextureUnit, filter TextureFilter) {
kinc_compute_set_texture_magnification_filter(*unit.ref, kinc_g4_texture_filter(filter))
}
func ComputeSetTextureMinificationFilter(unit ComputeTextureUnit, filter TextureFilter) {
kinc_compute_set_texture_minification_filter(*unit.ref, kinc_g4_texture_filter(filter))
}
func ComputeSetTexture3DMagnificationFilter(unit ComputeTextureUnit, filter TextureFilter) {
kinc_compute_set_texture3d_magnification_filter(*unit.ref, kinc_g4_texture_filter(filter))
}
func ComputeSetTexture3DMinificationFilter(unit ComputeTextureUnit, filter TextureFilter) {
kinc_compute_set_texture3d_minification_filter(*unit.ref, kinc_g4_texture_filter(filter))
}
func ComputeSetTextureMipmapFilter(unit ComputeTextureUnit, filter MipmapFilter) {
kinc_compute_set_texture_mipmap_filter(*unit.ref, kinc_g4_mipmap_filter(filter))
}
func ComputeSetTexture3DMipmapFilter(unit ComputeTextureUnit, filter MipmapFilter) {
kinc_compute_set_texture3d_mipmap_filter(*unit.ref, kinc_g4_mipmap_filter(filter))
}
func ComputeSetShader(shader *ComputeShader) {
kinc_compute_set_shader(shader.ref)
}
func Compute(x int32, y int32, z int32) {
kinc_compute(x, y, z)
}
type Shader struct {
ref *kinc_g4_shader
}
type ShaderType kinc_g4_shader_type
const (
SHADER_TYPE_FRAGMENT ShaderType = 0
SHADER_TYPE_VERTEX ShaderType = 1
SHADER_TYPE_GEOMETRY ShaderType = 2
SHADER_TYPE_TESSELLATION_CONTROL ShaderType = 3
SHADER_TYPE_TESSELLATION_EVALUATION ShaderType = 4
)
func ShaderInit(data []byte, length uint, _type ShaderType) *Shader {
shader := &Shader{
ref: &kinc_g4_shader{},
}
kinc_g4_shader_init(shader.ref, unsafe.Pointer(&data), length, kinc_g4_shader_type(_type))
return shader
}
func ShaderInitFromSource(source string, _type ShaderType) *Shader {
shader := &Shader{
ref: &kinc_g4_shader{},
}
kinc_g4_shader_init_from_source(shader.ref, source, kinc_g4_shader_type(_type))
return shader
}
func (shader *Shader) Destroy() {
kinc_g4_shader_destroy(shader.ref)
} | kinc/shader.go | 0.740456 | 0.527438 | shader.go | starcoder |
package functions
import (
"fmt"
"math/rand"
"time"
)
// Boring function will print a message with a counter in random periods
func Boring(msg string) {
for i :=0; ; i++ {
fmt.Printf("%s %d\n", msg, i)
time.Sleep(time.Duration(rand.Intn(2e3)) * time.Millisecond)
}
}
// BoringWithChannelInput will write message to the channel
func BoringWithChannelInput(msg string, c chan string) {
for i := 0; ; i++ {
c <- fmt.Sprintf("%s %d", msg, i)
time.Sleep(time.Duration(rand.Intn(2e3)) * time.Millisecond)
}
}
// BoringReturnsChannel returns a channel which will in turn stream messages
func BoringReturnsChannel(msg string) <-chan string {
c := make(chan string)
go func() {
for i := 0; ; i++ {
c <- fmt.Sprintf("%s %d", msg, i)
time.Sleep(time.Duration(rand.Intn(2e3)) * time.Millisecond)
}
}()
return c
}
// FanIn will receive two channels and will return one
func FanIn(input1, input2 <-chan string) <-chan string {
c := make(chan string)
go func() { for { c <- <-input1 } }()
go func() { for { c <- <-input2 } }()
return c
}
// Message struct is used dor synchronizing fan in function
type Message struct {
Msg string
Wait chan bool
}
// BoringMessage returns a receive only Message channel
func BoringMessage(msg string) <-chan Message {
c := make(chan Message)
waitForIt := make(chan bool)
go func() {
for i := 0; ; i++ {
c <- Message{fmt.Sprintf("%s %d", msg, i), waitForIt}
time.Sleep(time.Duration(rand.Intn(2e3)) * time.Millisecond)
<-waitForIt
}
}()
return c
}
// FanInMessage receives 2 receive only Message channels and returns single
func FanInMessage(input1, input2 <-chan Message) <-chan Message {
c := make(chan Message)
go func() { for { c <- <-input1 } }()
go func() { for { c <- <-input2 } }()
return c
}
// FanInUsingSelect uses a select block to synchronize messages from 2 channels
func FanInUsingSelect(input1, input2 <-chan string) <-chan string {
c := make(chan string)
go func() {
for {
select {
case s := <-input1:
c <- s
case s := <-input2:
c <- s
}
}
}()
return c
}
// BoringOnQuit stops printing messages till it receives a value on the quit channel
func BoringOnQuit(msg string, quit <-chan bool) <-chan string {
c := make(chan string)
go func() {
for i := 0; ; i++ {
select {
case c <- fmt.Sprintf("%s %d", msg, i):
time.Sleep(time.Duration(rand.Intn(1e3)) * time.Millisecond)
case <-quit:
return
}
}
}()
return c
}
// BoringCleanup will cleanup just before program exits
func BoringCleanup(msg string, quit chan string) <-chan string {
c := make(chan string)
go func() {
for i := 0; ;i++ {
select {
case c <- fmt.Sprintf("%s %d", msg, i):
time.Sleep(time.Duration(rand.Intn(1e3)) * time.Millisecond)
case <-quit:
cleanup()
quit <- "See you"
return
}
}
}()
return c
}
func cleanup() {
fmt.Println("Cleaning up....")
time.Sleep(1 * time.Second)
fmt.Println("Cleanup completed")
} | functions/boring.go | 0.564339 | 0.431345 | boring.go | starcoder |
package main
import (
"sort"
"github.com/otyg/threagile/model"
"github.com/otyg/threagile/model/confidentiality"
"github.com/otyg/threagile/model/criticality"
)
type missingNetworkSegmentation string
var RiskRule missingNetworkSegmentation
const raaLimit = 50
func (r missingNetworkSegmentation) Category() model.RiskCategory {
return model.RiskCategory{
Id: "missing-network-segmentation",
Title: "Missing Network Segmentation",
Description: "Highly sensitive assets and/or datastores residing in the same network segment than other " +
"lower sensitive assets (like webservers or content management systems etc.) should be better protected " +
"by a network segmentation trust-boundary.",
Impact: "If this risk is unmitigated, attackers successfully attacking other components of the system might have an easy path towards " +
"more valuable targets, as they are not separated by network segmentation.",
ASVS: "[v4.0.3-V1 - Architecture, Design and Threat Modeling Requirements](https://github.com/OWASP/ASVS/blob/v4.0.3_release/4.0/en/0x10-V1-Architecture.md)",
CheatSheet: "[Attack Surface Analysis Cheat Sheet](https://cheatsheetseries.owasp.org/cheatsheets/Attack_Surface_Analysis_Cheat_Sheet.html)",
Action: "Network Segmentation",
Mitigation: "Apply a network segmentation trust-boundary around the highly sensitive assets and/or datastores.",
Check: "Are recommendations from the linked cheat sheet and referenced ASVS chapter applied?",
Function: model.Operations,
STRIDE: model.ElevationOfPrivilege,
DetectionLogic: "In-scope technical assets with high sensitivity and RAA values as well as datastores " +
"when surrounded by assets (without a network trust-boundary in-between) which are of type " + model.ClientSystem.String() + ", " +
model.WebServer.String() + ", " + model.WebApplication.String() + ", " + model.CMS.String() + ", " + model.WebServiceREST.String() + ", " + model.WebServiceSOAP.String() + ", " +
model.BuildPipeline.String() + ", " + model.SourcecodeRepository.String() + ", " + model.Monitoring.String() + ", or similar and there is no direct connection between these " +
"(hence no requirement to be so close to each other).",
RiskAssessment: "Default is " + model.LowSeverity.String() + " risk. The risk is increased to " + model.MediumSeverity.String() + " when the asset missing the " +
"trust-boundary protection is rated as " + confidentiality.StrictlyConfidential.String() + " or " + criticality.MissionCritical.String() + ".",
FalsePositives: "When all assets within the network segmentation trust-boundary are hardened and protected to the same extend as if all were " +
"containing/processing highly sensitive data.",
ModelFailurePossibleReason: false,
CWE: 1008,
}
}
func (r missingNetworkSegmentation) SupportedTags() []string {
return []string{}
}
func (r missingNetworkSegmentation) GenerateRisks() []model.Risk {
risks := make([]model.Risk, 0)
// first create them in memory (see the link replacement below for nested trust boundaries) - otherwise in Go ranging over map is random order
// range over them in sorted (hence re-producible) way:
keys := make([]string, 0)
for k, _ := range model.ParsedModelRoot.TechnicalAssets {
keys = append(keys, k)
}
sort.Strings(keys)
for _, key := range keys {
technicalAsset := model.ParsedModelRoot.TechnicalAssets[key]
if !technicalAsset.OutOfScope && technicalAsset.Technology != model.ReverseProxy && technicalAsset.Technology != model.WAF && technicalAsset.Technology != model.IDS && technicalAsset.Technology != model.IPS && technicalAsset.Technology != model.ServiceRegistry {
if technicalAsset.RAA >= raaLimit && (technicalAsset.Type == model.Datastore || technicalAsset.Confidentiality >= confidentiality.Confidential ||
technicalAsset.Integrity >= criticality.Critical || technicalAsset.Availability >= criticality.Critical) {
// now check for any other same-network assets of certain types which have no direct connection
for _, sparringAssetCandidateId := range keys { // so inner loop again over all assets
if technicalAsset.Id != sparringAssetCandidateId {
sparringAssetCandidate := model.ParsedModelRoot.TechnicalAssets[sparringAssetCandidateId]
if sparringAssetCandidate.Technology.IsLessProtectedType() &&
technicalAsset.IsSameTrustBoundaryNetworkOnly(sparringAssetCandidateId) &&
!technicalAsset.HasDirectConnection(sparringAssetCandidateId) &&
!sparringAssetCandidate.Technology.IsCloseToHighValueTargetsTolerated() {
highRisk := technicalAsset.Confidentiality == confidentiality.StrictlyConfidential ||
technicalAsset.Integrity == criticality.MissionCritical || technicalAsset.Availability == criticality.MissionCritical
risks = append(risks, createRisk(technicalAsset, highRisk))
break
}
}
}
}
}
}
return risks
}
func createRisk(techAsset model.TechnicalAsset, moreRisky bool) model.Risk {
impact := model.LowImpact
if moreRisky {
impact = model.MediumImpact
}
risk := model.Risk{
Category: RiskRule.Category(),
Severity: model.CalculateSeverity(model.Unlikely, impact),
ExploitationLikelihood: model.Unlikely,
ExploitationImpact: impact,
Title: "<b>Missing Network Segmentation</b> to further encapsulate and protect <b>" + techAsset.Title + "</b> against unrelated " +
"lower protected assets in the same network segment, which might be easier to compromise by attackers",
MostRelevantTechnicalAssetId: techAsset.Id,
DataBreachProbability: model.Improbable,
DataBreachTechnicalAssetIDs: []string{techAsset.Id},
}
risk.SyntheticId = risk.Category.Id + "@" + techAsset.Id
return risk
} | risks/missing-network-segmentation/missing-network-segmentation-rule.go | 0.743075 | 0.421611 | missing-network-segmentation-rule.go | starcoder |
The Go package simplecsv is a simple mini-library to handle csv files. I'm building it to help me writing small command line scripts. Maybe it's useful to someone else as well.
Some notes:
- all read methods return the value in the csv and a second true/false value that is true if the value exists
- all write methods that change the csv return the changed csv and a true/false value if the operation was sucessful
- all cells are strings
- Simplecsv works with comma separated csv files.
* CSV FILE *
READ
Reads file and parses as a SimpleCsv object. `fileRead` is false if there's an error reading the file or parsing the CSV.
var x simplecsv.SimpleCsv
x, fileRead = simplecsv.ReadCsvFile("my1file.csv")
CREATE
Create empty file and define cssv headers:
var u simplecsv.SimpleCsv
u = simplecsv.CreateEmpyCsv([]string{"Age", "Gender", "ID"})
WRITE
Write the SimpleCsv object to my2file.csv. If there's an error, `wasWritten` is false.
wasWritten := u.WriteCsvFile("my2file.csv")
* HEADERS *
The cells of the first row are considered headers.
GET
Get all headers:
headers := x.GetHeaders()
Get header at position one (second position as it starts from 0):
headerName, headerExists := x.GetHeader(1)
Get header position: (it returns `-1` if the header does not exist)
position := x.GetHeaderPosition("Gender")
RENAME
Rename header: (old header, new header)
x, headerExists := x.RenameHeader("ID", "IDnumber")
`headerExists` is false if the old header does not exist.
* ROWS *
GET
Get number of rows:
numberOfRows := x.GetNumberRows()
Get second row:
row, rowExists := x.GetRow(1)
Get second row as a map:
row, rowExists := x.GetRowAsMap(1)
ADD
Add a slice to a row. The slice must have the same size as the CSV number of columns. If not wasSucessful is false.
x, wasSucessful = x.AddRow([]string{"24", "M", "2986732"})
Add row from map: (If the map keys don't exist as columns, the value will be discarded. If a key does not exist, it will create empty cells.)
mymap := make(map[string]string)
mymap["Age"] = "62"
mymap["Gender"] = "F"
mymap["ID"] = "6463246"
x, wasAdded = x.AddRowFromMap(mymap)
SET
Set second row (1) from a slice. The length of the slice must be the same as the number of columns and the row must already exist. If there’s an error `wasSet` is false.
x, wasSet = x.SetRow(1, []string{"45", "F", "8356138"})
Set second row from map: If the map keys don't exist as columns, the value will be discarded. If a key does not exist, it will create empty cells.)
mymap2 := make(map[string]string)
mymap2["Age"] = "62"
mymap2["Gender"] = "F"
mymap2["ID"] = "6463246"
x, wasAdded = x.SetRowFromMap(1, mymap2)
DELETE
Delete second row: (If the row number is invalid, `wasDeleted` is false)
x, wasDeleted = x.DeleteRow(1)
* CELLS *
.
*/
package simplecsv | doc.go | 0.590661 | 0.586819 | doc.go | starcoder |
package vector2f
type Rect struct {
Min Vector2f
Max Vector2f
// X, Y float64
// W, H float64
}
func NewRect(v1, v2 Vector2f) Rect {
rtn := Rect{
Min: v1,
Max: v2,
}
for i := 0; i < 2; i++ {
if rtn.Min[i] > rtn.Max[i] {
rtn.Max[i], rtn.Min[i] = rtn.Min[i], rtn.Max[i]
}
}
return rtn
}
func NewRectCenterWH(ctVt, whVt Vector2f) Rect {
rtn := Rect{
Min: ctVt,
Max: ctVt.Add(whVt),
}
for i := 0; i < 2; i++ {
if rtn.Min[i] > rtn.Max[i] {
rtn.Max[i] = rtn.Min[i]
rtn.Min[i] = rtn.Max[i]
}
}
return rtn
}
func (rt Rect) Center() Vector2f {
return rt.Min.Add(rt.Max).DivF(2)
}
func (rt Rect) DiagLen() float64 {
return rt.Min.LenTo(rt.Max)
}
func (rt Rect) SizeVector() Vector2f {
return rt.Max.Sub(rt.Min)
}
// func (rt Rect) Enlarge(size Vector2f) Rect {
// return Rect{
// rt.X - size[0], rt.Y - size[1],
// rt.W + size[0]*2, rt.H + size[1]*2,
// }
// }
// func (rt Rect) Shrink(size Vector2f) Rect {
// return Rect{
// rt.X + size[0], rt.Y + size[1],
// rt.W - size[0]*2, rt.H - size[1]*2,
// }
// }
// func (rt Rect) ShrinkSym(n float64) Rect {
// return Rect{rt.X + n, rt.Y + n, rt.W - n*2, rt.H - n*2}
// }
// func (rt Rect) X1() float64 {
// return rt.X
// }
// func (rt Rect) X2() float64 {
// return rt.X + rt.W
// }
// func (rt Rect) Y1() float64 {
// return rt.Y
// }
// func (rt Rect) Y2() float64 {
// return rt.Y + rt.H
// }
func (r1 Rect) IsOverlap(r2 Rect) bool {
return !((r1.Min[0] >= r2.Max[0] || r1.Max[0] <= r2.Min[0]) ||
(r1.Min[1] >= r2.Max[1] || r1.Max[1] <= r2.Min[1]))
}
func (r1 Rect) IsIn(r2 Rect) bool {
if r1.Min[0] < r2.Min[0] || r1.Max[0] > r2.Max[0] {
return false
}
if r1.Min[1] < r2.Min[1] || r1.Max[1] > r2.Max[1] {
return false
}
return true
}
func min(i, j float64) float64 {
if i < j {
return i
}
return j
}
func max(i, j float64) float64 {
if i > j {
return i
}
return j
}
func (r1 Rect) Union(r2 Rect) Rect {
rt := Rect{
Vector2f{
min(r1.Min[0], r2.Min[0]),
min(r1.Min[1], r2.Min[1])},
Vector2f{
max(r1.Max[0], r2.Max[0]),
max(r1.Max[1], r2.Max[1]),
},
}
return rt
}
func (r1 Rect) Intersection(r2 Rect) Rect {
rt := Rect{
Vector2f{
max(r1.Min[0], r2.Min[0]),
max(r1.Min[1], r2.Min[1]),
},
Vector2f{
min(r1.Max[0], r2.Max[0]),
min(r1.Max[1], r2.Max[1]),
},
}
return rt
}
func (rt Rect) Contain(vt Vector2f) bool {
return rt.Min[0] <= vt[0] && vt[0] <= rt.Max[0] &&
rt.Min[1] <= vt[1] && vt[1] <= rt.Max[1]
}
// func (rt Rect) RelPos(x, y float64) (float64, float64) {
// return x - rt.X, y - rt.Y
// }
func (rt Rect) WrapVector(vt Vector2f) Vector2f {
if vt[0] < rt.Min[0] {
vt[0] = rt.Max[0]
}
if vt[1] < rt.Min[1] {
vt[1] = rt.Max[1]
}
if vt[0] > rt.Max[0] {
vt[0] = rt.Min[0]
}
if vt[1] > rt.Max[1] {
vt[1] = rt.Min[1]
}
return vt
} | lib/vector2f/rect.go | 0.592313 | 0.573917 | rect.go | starcoder |
package header
/**
* The Warning header field is used to carry additional information about the
* status of a response. Warning header field values are sent with responses
* and contain a three-digit warning code, agent name, and warning text.
* <ul>
* <li>Warning Text: The "warn-text" should be in a natural language that is
* most likely to be intelligible to the human user receiving the response.
* This decision can be based on any available knowledge, such as the location
* of the user, the Accept-Language field in a request, or the Content-Language
* field in a response.
* <li>Warning Code: The currently-defined "warn-code"s have a recommended
* warn-text in English and a description of their meaning. These warnings
* describe failures induced by the session description. The first digit of
* warning codes beginning with "3" indicates warnings specific to SIP. Warnings
* 300 through 329 are reserved for indicating problems with keywords in the
* session description, 330 through 339 are warnings related to basic network
* services requested in the session description, 370 through 379 are warnings
* related to quantitative QoS parameters requested in the session description,
* and 390 through 399 are miscellaneous warnings that do not fall into one of
* the above categories. Additional "warn-code"s can be defined.
* </ul>
* Any server may add WarningHeaders to a Response. Proxy servers must place
* additional WarningHeaders before any AuthorizationHeaders. Within that
* constraint, WarningHeaders must be added after any existing WarningHeaders
* not covered by a signature. A proxy server must not delete any WarningHeader
* that it received with a Response.
* <p>
* When multiple WarningHeaders are attached to a Response, the user agent
* should display as many of them as possible, in the order that they appear
* in the Response. If it is not possible to display all of the warnings, the
* user agent first displays warnings that appear early in the Response.
* <p>
* Examples of using Warning Headers are as follows:
* <ul>
* <li>A UAS rejecting an offer contained in an INVITE SHOULD return a 488 (Not
* Acceptable Here) response. Such a response SHOULD include a Warning header
* field value explaining why the offer was rejected.
* <li>If the new session description is not acceptable, the UAS can reject it
* by returning a 488 (Not Acceptable Here) response for the re-INVITE. This
* response SHOULD include a Warning header field.
* <li>A 606 (Not Acceptable) response means that the user wishes to communicate,
* but cannot adequately support the session described. The 606 (Not Acceptable)
* response MAY contain a list of reasons in a Warning header field describing
* why the session described cannot be supported.
* <li>Contact header fields MAY be present in a 200 (OK) response and have the
* same semantics as in a 3xx response. That is, they may list a set of
* alternative names and methods of reaching the user. A Warning header field
* MAY be present.
* </ul>
* For Example:<br>
* <code>Warning: 307 isi.edu "Session parameter 'foo' not understood"</code>
*/
type WarningHeader interface {
Header
/**
* Gets the agent of the server that created this WarningHeader.
*
* @return the agent of the WarningHeader
*/
GetAgent() string
/**
* Sets the agent value of the WarningHeader to the new value passed to the
* method.
*
* @param agent - the new agent value of WarningHeader
* @throws ParseException which signals that an error has been reached
* unexpectedly while parsing the agent value.
*/
SetAgent(agent string) (ParseException error)
/**
* Gets text of WarningHeader.
*
* @return the string text value of the WarningHeader.
*/
GetText() string
/**
* Sets the text of WarningHeader to the newly supplied text value.
*
* @param text - the new text value of the Warning Header.
* @throws ParseException which signals that an error has been reached
* unexpectedly while parsing the text value.
*/
SetText(text string) (ParseException error)
/**
* Sets the code of the WarningHeader. The standard RFC3261 codes are
* defined as constants in this class.
*
* @param code - the new code that defines the warning code.
* @throws InvalidArgumentException if an invalid integer code is given for
* the WarningHeader.
*/
SetCode(code int) (InvalidArgumentException error)
/**
* Gets the code of the WarningHeader.
*
* @return the integer code value of the WarningHeader
*/
GetCode() int
}
const (
/**
* One or more network protocols contained in the session description
* are not available.
*/
INCOMPATIBLE_NETWORK_PROTOCOL = 300
/**
* One or more network address formats contained in the session
* description are not available.
*/
INCOMPATIBLE_NETWORK_ADDRESS_FORMATS = 301
/**
* One or more transport protocols described in the session description
* are not available.
*/
INCOMPATIBLE_TRANSPORT_PROTOCOL = 302
/**
* One or more bandwidth measurement units contained in the session
* description were not understood.
*/
INCOMPATIBLE_BANDWIDTH_UNITS = 303
/**
* One or more media types contained in the session description are
* not available.
*/
MEDIA_TYPE_NOT_AVAILABLE = 304
/**
* One or more media formats contained in the session description are
* not available.
*/
INCOMPATIBLE_MEDIA_FORMAT = 305
/**
* One or more of the media attributes in the session description are
* not supported.
*/
ATTRIBUTE_NOT_UNDERSTOOD = 306
/**
* A parameter other than those listed above was not understood.
*/
SESSION_DESCRIPTION_PARAMETER_NOT_UNDERSTOOD = 307
/**
* The site where the user is located does not support multicast.
*/
MULTICAST_NOT_AVAILABLE = 330
/**
* The site where the user is located does not support unicast
* communication (usually due to the presence of a firewall).
*/
UNICAST_NOT_AVAILABLE = 331
/**
* The bandwidth specified in the session description or defined by the
* media exceeds that known to be available.
*/
INSUFFICIENT_BANDWIDTH = 370
/**
* The warning text can include arbitrary information to be presented to
* a human user, or logged. A system receiving this warning MUST NOT
* take any automated action.
*/
MISCELLANEOUS_WARNING = 399
) | sip/header/WarningHeader.go | 0.857365 | 0.458955 | WarningHeader.go | starcoder |
package cryptypes
import "database/sql/driver"
// EncryptedUint8 supports encrypting Uint8 data
type EncryptedUint8 struct {
Field
Raw uint8
}
// Scan converts the value from the DB into a usable EncryptedUint8 value
func (s *EncryptedUint8) Scan(value interface{}) error {
return decrypt(value.([]byte), &s.Raw)
}
// Value converts an initialized EncryptedUint8 value into a value that can safely be stored in the DB
func (s EncryptedUint8) Value() (driver.Value, error) {
return encrypt(s.Raw)
}
// NullEncryptedUint8 supports encrypting nullable Uint8 data
type NullEncryptedUint8 struct {
Field
Raw uint8
Empty bool
}
// Scan converts the value from the DB into a usable NullEncryptedUint8 value
func (s *NullEncryptedUint8) Scan(value interface{}) error {
if value == nil {
s.Raw = 0
s.Empty = true
return nil
}
return decrypt(value.([]byte), &s.Raw)
}
// Value converts an initialized NullEncryptedUint8 value into a value that can safely be stored in the DB
func (s NullEncryptedUint8) Value() (driver.Value, error) {
if s.Empty {
return nil, nil
}
return encrypt(s.Raw)
}
// SignedUint8 supports signing Uint8 data
type SignedUint8 struct {
Field
Raw uint8
Valid bool
}
// Scan converts the value from the DB into a usable SignedUint8 value
func (s *SignedUint8) Scan(value interface{}) (err error) {
s.Valid, err = verify(value.([]byte), &s.Raw)
return
}
// Value converts an initialized SignedUint8 value into a value that can safely be stored in the DB
func (s SignedUint8) Value() (driver.Value, error) {
return sign(s.Raw)
}
// NullSignedUint8 supports signing nullable Uint8 data
type NullSignedUint8 struct {
Field
Raw uint8
Empty bool
Valid bool
}
// Scan converts the value from the DB into a usable NullSignedUint8 value
func (s *NullSignedUint8) Scan(value interface{}) (err error) {
if value == nil {
s.Raw = 0
s.Empty = true
s.Valid = true
return nil
}
s.Valid, err = verify(value.([]byte), &s.Raw)
return
}
// Value converts an initialized NullSignedUint8 value into a value that can safely be stored in the DB
func (s NullSignedUint8) Value() (driver.Value, error) {
if s.Empty {
return nil, nil
}
return sign(s.Raw)
}
// SignedEncryptedUint8 supports signing and encrypting Uint8 data
type SignedEncryptedUint8 struct {
Field
Raw uint8
Valid bool
}
// Scan converts the value from the DB into a usable SignedEncryptedUint8 value
func (s *SignedEncryptedUint8) Scan(value interface{}) (err error) {
s.Valid, err = decryptVerify(value.([]byte), &s.Raw)
return
}
// Value converts an initialized SignedEncryptedUint8 value into a value that can safely be stored in the DB
func (s SignedEncryptedUint8) Value() (driver.Value, error) {
return encryptSign(s.Raw)
}
// NullSignedEncryptedUint8 supports signing and encrypting nullable Uint8 data
type NullSignedEncryptedUint8 struct {
Field
Raw uint8
Empty bool
Valid bool
}
// Scan converts the value from the DB into a usable NullSignedEncryptedUint8 value
func (s *NullSignedEncryptedUint8) Scan(value interface{}) (err error) {
if value == nil {
s.Raw = 0
s.Empty = true
s.Valid = true
return nil
}
s.Valid, err = decryptVerify(value.([]byte), &s.Raw)
return
}
// Value converts an initialized NullSignedEncryptedUint8 value into a value that can safely be stored in the DB
func (s NullSignedEncryptedUint8) Value() (driver.Value, error) {
if s.Empty {
return nil, nil
}
return encryptSign(s.Raw)
} | cryptypes/type_uint8.go | 0.80406 | 0.407923 | type_uint8.go | starcoder |
package prommatch
import (
"bytes"
"fmt"
"regexp"
dto "github.com/prometheus/client_model/go"
"github.com/prometheus/common/expfmt"
"github.com/prometheus/common/model"
)
// Expression can match or reject one time series.
type Expression interface {
matches(sp *model.Sample) bool
}
type funcMatcher func(sp *model.Sample) bool
func (fc funcMatcher) matches(sp *model.Sample) bool {
return fc(sp)
}
// NewMatcher will match series name (exactly) and all the additional matchers.
func NewMatcher(name string, ms ...Expression) *Matcher {
return &Matcher{
expressions: append([]Expression{hasName(name)}, ms...),
}
}
// Matcher contains a list of expressions, which will be checked against each series.
type Matcher struct {
expressions []Expression
}
// HasMatchInString will return:
// - true, if the provided metrics have a series which matches all expressions,
// - false, if none of the series matches,
// - error, if the provided string is not valid Prometheus metrics,
func (e *Matcher) HasMatchInString(s string) (bool, error) {
v, err := extractSamplesVectorFromString(s)
if err != nil {
return false, fmt.Errorf("failed to parse input string as vector of samples: %w", err)
}
return e.hasMatchInVector(v), nil
}
func (e *Matcher) hasMatchInVector(v model.Vector) bool {
for _, s := range v {
if e.sampleMatches(s) {
return true
}
}
return false
}
func (e *Matcher) sampleMatches(s *model.Sample) bool {
for _, m := range e.expressions {
if !m.matches(s) {
return false
}
}
return true
}
// LabelMatcher can match or reject a label's value.
type LabelMatcher func(string) bool
// Labels is used for selecting series with matching labels.
type Labels map[string]LabelMatcher
// Make sure Labels implement Expression.
var _ Expression = Labels{}
func (l Labels) matches(s *model.Sample) bool {
for k, m := range l {
labelValue := s.Metric[model.LabelName(k)]
if !m(string(labelValue)) {
return false
}
}
return true
}
// Equals is when you want label value to have an exact value.
func Equals(expected string) LabelMatcher {
return func(s string) bool {
return expected == s
}
}
// Like is when you want label value to match a regular expression.
func Like(re *regexp.Regexp) LabelMatcher {
return func(s string) bool {
return re.MatchString(s)
}
}
// Absent is when you want to match series MISSING a specific label.
func Absent() LabelMatcher {
return func(s string) bool {
return s == ""
}
}
// Any is when you want to select a series which has a certain label, but don't care about the value.
func Any() LabelMatcher {
return func(s string) bool {
return s != ""
}
}
// HasValueLike is used for selecting time series based on value.
func HasValueLike(f func(float64) bool) Expression {
return funcMatcher(func(sp *model.Sample) bool {
return f(float64(sp.Value))
})
}
// HasValueOf is used for selecting time series based on a specific value.
func HasValueOf(f float64) Expression {
return funcMatcher(func(sp *model.Sample) bool {
return f == float64(sp.Value)
})
}
// HasPositiveValue is used to select time series with a positive value.
func HasPositiveValue() Expression {
return HasValueLike(func(f float64) bool {
return f > 0
})
}
func hasName(metricName string) Expression {
return funcMatcher(func(sp *model.Sample) bool {
return sp.Metric[model.MetricNameLabel] == model.LabelValue(metricName)
})
}
func extractSamplesVectorFromString(s string) (model.Vector, error) {
bb := bytes.NewBufferString(s)
p := &expfmt.TextParser{}
metricFamilies, err := p.TextToMetricFamilies(bb)
if err != nil {
return nil, fmt.Errorf("failed to parse input as metrics: %w", err)
}
var mfs []*dto.MetricFamily
for _, m := range metricFamilies {
mfs = append(mfs, m)
}
v, err := expfmt.ExtractSamples(&expfmt.DecodeOptions{}, mfs...)
if err != nil {
return nil, fmt.Errorf("failed to extract samples from input: %w", err)
}
return v, nil
} | testutil/prommatch/prommatch.go | 0.779825 | 0.491273 | prommatch.go | starcoder |
package sexp
func (atom Bool) Copy() Form { return Bool(atom) }
func (atom Int) Copy() Form { return Int(atom) }
func (atom Float) Copy() Form { return Float(atom) }
func (atom Str) Copy() Form { return Str(atom) }
func (atom Symbol) Copy() Form { return Symbol(atom) }
func (atom Var) Copy() Form {
return Var{Name: atom.Name, Typ: atom.Typ}
}
func (atom Local) Copy() Form {
return Local{Name: atom.Name, Typ: atom.Typ}
}
func (lit *ArrayLit) Copy() Form {
return &ArrayLit{Vals: CopyList(lit.Vals), Typ: lit.Typ}
}
func (lit *SparseArrayLit) Copy() Form {
return &SparseArrayLit{
Ctor: lit.Ctor.Copy(),
Vals: CopyList(lit.Vals),
Indexes: append([]int(nil), lit.Indexes...),
Typ: lit.Typ,
}
}
func (lit *SliceLit) Copy() Form {
return &SliceLit{Vals: CopyList(lit.Vals), Typ: lit.Typ}
}
func (lit *StructLit) Copy() Form {
return &StructLit{Vals: CopyList(lit.Vals), Typ: lit.Typ}
}
func (form *ArrayUpdate) Copy() Form {
return &ArrayUpdate{
Array: form.Array.Copy(),
Index: form.Index.Copy(),
Expr: form.Expr.Copy(),
}
}
func (form *SliceUpdate) Copy() Form {
return &SliceUpdate{
Slice: form.Slice.Copy(),
Index: form.Index.Copy(),
Expr: form.Expr.Copy(),
}
}
func (form *StructUpdate) Copy() Form {
return &StructUpdate{
Struct: form.Struct.Copy(),
Index: form.Index,
Expr: form.Expr.Copy(),
Typ: form.Typ,
}
}
func (form *Bind) Copy() Form {
return &Bind{Name: form.Name, Init: form.Init.Copy()}
}
func (form *Rebind) Copy() Form {
return &Rebind{Name: form.Name, Expr: form.Expr.Copy()}
}
func (form *VarUpdate) Copy() Form {
return &VarUpdate{Expr: form.Expr.Copy()}
}
func (form FormList) Copy() Form {
return FormList(CopyList(form))
}
func (form Block) Copy() Form {
return Block(CopyList(form))
}
func (form *If) Copy() Form {
return &If{
Cond: form.Cond.Copy(),
Then: form.Then.Copy().(Block),
Else: form.Else.Copy(),
}
}
func (form *Switch) Copy() Form {
return &Switch{
Expr: form.Expr.Copy(),
SwitchBody: copySwitchBody(form.SwitchBody),
}
}
func (form *SwitchTrue) Copy() Form {
return &SwitchTrue{SwitchBody: copySwitchBody(form.SwitchBody)}
}
func (form *Return) Copy() Form {
return &Return{Results: CopyList(form.Results)}
}
func (form *ExprStmt) Copy() Form {
return &ExprStmt{Expr: form.Expr.Copy()}
}
func (form *Goto) Copy() Form { return &Goto{LabelName: form.LabelName} }
func (form *Label) Copy() Form { return &Label{Name: form.Name} }
func (form *Repeat) Copy() Form {
return &Repeat{
N: form.N,
Body: form.Body.Copy().(Block),
}
}
func (form *DoTimes) Copy() Form {
return &DoTimes{
N: form.N.Copy(),
Iter: form.Iter,
Step: form.Step.Copy(),
Body: form.Body.Copy().(Block),
}
}
func (form *Loop) Copy() Form {
return &Loop{
Init: form.Init.Copy(),
Post: form.Post.Copy(),
Body: form.Body.Copy().(Block),
}
}
func (form *While) Copy() Form {
return &While{
Init: form.Init.Copy(),
Cond: form.Cond.Copy(),
Post: form.Post.Copy(),
Body: form.Body.Copy().(Block),
}
}
func (form *ArrayIndex) Copy() Form {
return &ArrayIndex{
Array: form.Array.Copy(),
Index: form.Index.Copy(),
}
}
func (form *SliceIndex) Copy() Form {
return &SliceIndex{
Slice: form.Slice.Copy(),
Index: form.Index.Copy(),
}
}
func (form *StructIndex) Copy() Form {
return &StructIndex{
Struct: form.Struct.Copy(),
Index: form.Index,
Typ: form.Typ,
}
}
func (form *ArraySlice) Copy() Form {
return &ArraySlice{
Array: form.Array.Copy(),
Typ: form.Typ,
Span: copySpan(form.Span),
}
}
func (form *SliceSlice) Copy() Form {
return &SliceSlice{
Slice: form.Slice.Copy(),
Span: copySpan(form.Span),
}
}
func (form *TypeAssert) Copy() Form {
return &TypeAssert{Expr: form.Expr.Copy(), Typ: form.Typ}
}
func (call *Call) Copy() Form {
return &Call{Fn: call.Fn, Args: CopyList(call.Args)}
}
func (call *LispCall) Copy() Form {
return &LispCall{Fn: call.Fn, Args: CopyList(call.Args)}
}
func (call *LambdaCall) Copy() Form {
return &LambdaCall{
Args: copyBindList(call.Args),
Body: call.Body.Copy().(Block),
Typ: call.Typ,
}
}
func (call *DynCall) Copy() Form {
return &DynCall{
Callable: call.Callable.Copy(),
Args: CopyList(call.Args),
Typ: call.Typ,
}
}
func (form *Let) Copy() Form {
binds := copyBindList(form.Bindings)
if form.Expr != nil {
return &Let{Bindings: binds, Expr: form.Expr.Copy()}
}
return &Let{Bindings: binds, Stmt: form.Stmt.Copy()}
}
func (form *TypeCast) Copy() Form {
return &TypeCast{Form: form.Form.Copy(), Typ: form.Typ}
}
func (form *And) Copy() Form {
return &And{X: form.X.Copy(), Y: form.Y.Copy()}
}
func (form *Or) Copy() Form {
return &Or{X: form.X.Copy(), Y: form.Y.Copy()}
}
func (form *emptyForm) Copy() Form { return form }
func CopyList(forms []Form) []Form {
if forms == nil {
return nil
}
res := make([]Form, len(forms))
for i, form := range forms {
res[i] = form.Copy()
}
return res
}
func copySpan(span Span) Span {
return Span{
Low: span.Low.Copy(),
High: span.High.Copy(),
}
}
func copySwitchBody(b SwitchBody) SwitchBody {
var clauses []CaseClause
if b.Clauses != nil {
clauses = make([]CaseClause, len(b.Clauses))
for i, cc := range b.Clauses {
clauses[i] = CaseClause{
Expr: cc.Expr.Copy(),
Body: cc.Body.Copy().(Block),
}
}
}
return SwitchBody{
Clauses: clauses,
DefaultBody: b.DefaultBody.Copy().(Block),
}
}
func copyCaseClauseList(clauses []CaseClause) []CaseClause {
if clauses == nil {
return nil
}
res := make([]CaseClause, len(clauses))
for i, cc := range clauses {
res[i] = CaseClause{
Expr: cc.Expr.Copy(),
Body: cc.Body.Copy().(Block),
}
}
return res
}
func copyBindList(binds []*Bind) []*Bind {
res := make([]*Bind, len(binds))
for i, bind := range binds {
res[i] = &Bind{
Name: bind.Name,
Init: bind.Init.Copy(),
}
}
return res
} | src/sexp/copy.go | 0.663887 | 0.4474 | copy.go | starcoder |
package maths
import (
"sync"
)
// Inspiration taken from golang.org/x/tour/tree
// A Tree is has a value and two sub trees.
type Tree struct {
Left *Tree
Value int
Right *Tree
}
// CreateBinaryTree returns a (mostly) symmetric binary tree, filling with values from top to bottom, left to right.
// CreateBinaryTree() returns <nil>
func CreateBinaryTree(values ...int) *Tree {
return createTree(false, values...)
}
// CreatePyramidTree returns a (mostly) symmetric pyramid tree, filling with values from top to bottom, left to right.
// CreatePyramidTree() returns <nil>
func CreatePyramidTree(values ...int) *Tree {
return createTree(true, values...)
}
func createTree(isPyramid bool, values ...int) *Tree {
if len(values) == 0 {
return nil
}
numberOfValues := len(values)
trees := make([]*Tree, numberOfValues)
// Create all the tree nodes.
for ind, val := range values {
trees[ind] = &Tree{nil, val, nil}
}
pyramidSet, pyramidLimit := 0, 0
// Take the tree nodes and link them together to build the tree structure.
i, j := 0, 1
for ; j < numberOfValues-1; i++ {
trees[i].Left = trees[j]
j++
trees[i].Right = trees[j]
if !isPyramid {
j++
} else if pyramidSet == pyramidLimit {
j++
pyramidSet = 0
pyramidLimit++
} else {
pyramidSet++
}
}
if j != numberOfValues {
trees[i].Left = trees[j]
}
return trees[0]
}
// MaxPath returns the largest of all the possible summations from top to bottom of a tree.
// The execution works up from the bottom of the pyramid. The maximum path to a node is the value of the node
// plus the maximum of the maximum paths to each child node.
// There is a natural recursive function but it fails when a pyramid tree gets too large and the function runs out of resources.
// MaxPath(<nil>) returns 0.
func MaxPath(t *Tree) int {
if t == nil {
return 0
}
maximumPaths := new(sync.Map)
for _, totalSumExists := maximumPaths.Load(t); !totalSumExists; _, totalSumExists = maximumPaths.Load(t) {
generateMaximumPaths(t, maximumPaths, new(sync.Map))
}
sum, _ := maximumPaths.Load(t)
return sum.(int)
}
func generateMaximumPaths(t *Tree, maximumPaths *sync.Map, channelsMap *sync.Map) {
_, ok := channelsMap.LoadOrStore(t, true) // Prevents duplicate generating paths.
if ok {
return
}
var leftMax, rightMax interface{} = 0, 0
leftMaxExists, rightMaxExists := true, true
if t.Left != nil {
leftMax, leftMaxExists = maximumPaths.Load(t.Left)
}
if !leftMaxExists {
go generateMaximumPaths(t.Left, maximumPaths, channelsMap)
}
if t.Right != nil {
rightMax, rightMaxExists = maximumPaths.Load(t.Right)
}
if !rightMaxExists {
go generateMaximumPaths(t.Right, maximumPaths, channelsMap)
}
if leftMaxExists && rightMaxExists {
maximumPaths.Store(t, Max(leftMax.(int), rightMax.(int))+t.Value)
}
} | tree.go | 0.788583 | 0.522385 | tree.go | starcoder |
package deregexp
import (
"fmt"
"strings"
)
// Node is either an AndNode or OrNode in the tree.
// The tree describes an expression of ANDs and ORs and words.
type Node interface {
Expr() string
}
// AndNode expresses a set of words and OrNodes that must all match for this node to match.
type AndNode struct {
Words []string
Children []OrNode
}
// OrNode expresses a set of words and AndNodes of which at least one must match for this node to match.
type OrNode struct {
Words []string
Children []AndNode
}
// Expr converts this node to a string.
func (n AndNode) Expr() string {
var parts []string
for _, w := range n.Words {
parts = append(parts, fmt.Sprintf("%q", w))
}
for _, o := range n.Children {
parts = append(parts, fmt.Sprintf("(%s)", o.Expr()))
}
return strings.Join(parts, " AND ")
}
// Expr converts this node to a string.
func (n OrNode) Expr() string {
var parts []string
for _, w := range n.Words {
parts = append(parts, fmt.Sprintf("%q", w))
}
for _, a := range n.Children {
parts = append(parts, fmt.Sprintf("(%s)", a.Expr()))
}
return strings.Join(parts, " OR ")
}
// append adds other to n and returns the new result.
// The new node is ANDed together with the existing node.
func (n AndNode) append(other Node) AndNode {
if other == nil {
return n
}
if a, ok := other.(AndNode); ok {
return AndNode{
Words: append(n.Words, a.Words...),
Children: append(n.Children, a.Children...),
}
}
o := other.(OrNode)
if len(o.Words)+len(o.Children) == 1 {
if len(o.Words) == 1 {
return AndNode{
Words: append(n.Words, o.Words[0]),
Children: n.Children,
}
}
return n.append(o.Children[0])
}
return AndNode{
Words: n.Words,
Children: append(n.Children, o),
}
}
// append adds other to n and returns the new result.
// The new node is ORed together with the existing node.
func (n OrNode) append(other Node) OrNode {
if other == nil {
return n
}
if o, ok := other.(OrNode); ok {
return OrNode{
Words: append(n.Words, o.Words...),
Children: append(n.Children, o.Children...),
}
}
o := other.(AndNode)
if len(o.Words)+len(o.Children) == 1 {
if len(o.Words) == 1 {
return OrNode{
Words: append(n.Words, o.Words[0]),
Children: n.Children,
}
}
return n.append(o.Children[0])
}
return OrNode{
Words: n.Words,
Children: append(n.Children, o),
}
}
// Treeify simplifies all possible options passed in into a node tree.
// Treeify tries to make the tree as simple as possible.
func Treeify(sequences [][]string) Node {
for _, o := range sequences {
if len(o) == 0 {
return nil
}
}
bestWord := mostCommon(sequences)
if bestWord == "" {
panic("no more words?")
}
var with, without [][]string
for _, o := range sequences {
if containsWord(o, bestWord) {
with = append(with, filterWordAndImplications(o, bestWord))
} else {
without = append(without, o)
}
}
wn := Treeify(with)
wn = AndNode{
Words: []string{bestWord},
}.append(wn)
if len(without) == 0 {
return wn
}
won := Treeify(without)
return OrNode{}.append(wn).append(won)
}
// mostCommon figures out which word is the most common among all options.
// If a word is a substring of another word, that makes the other word considered even more common.
func mostCommon(sequences [][]string) string {
words := map[string][]string{}
// First find all unique words.
for _, o := range sequences {
for _, w := range o {
words[w] = nil
}
}
// Now figure out for each word which words contain it as a substring.
for w1 := range words {
for w2 := range words {
if strings.Contains(w2, w1) {
words[w2] = append(words[w2], w1)
}
}
}
// Now score each word a point for every possible option it is in, giving at most one point per possibility to each word.
scores := map[string]int{}
for _, o := range sequences {
scored := map[string]bool{}
for _, w := range o {
for _, sw := range words[w] {
if !scored[sw] {
scored[sw] = true
scores[sw]++
}
}
}
}
// Find the highest scoring word in the map, breaking ties by longest word, then lexographically.
bestScore := 0
bestWord := ""
for w, s := range scores {
if s > bestScore || (s == bestScore && (len(w) > len(bestWord) || (len(w) == len(bestWord) && w < bestWord))) {
bestScore = s
bestWord = w
}
}
return bestWord
}
// filterWordAndImplications removes needle from haystack, and all words from haystack that are substrings of needle.
func filterWordAndImplications(haystack []string, needle string) []string {
ret := make([]string, 0, len(haystack))
for _, e := range haystack {
if !strings.Contains(needle, e) {
ret = append(ret, e)
}
}
return ret
}
// containsWord returns true if needle is a substring of any word in the haystack.
func containsWord(haystack []string, needle string) bool {
for _, w := range haystack {
if strings.Contains(w, needle) {
return true
}
}
return false
} | treeify.go | 0.628749 | 0.419529 | treeify.go | starcoder |
package schema
// language=JSON
const V1 = `{
"$schema": "http://json-schema.org/draft-07/schema#",
"id": "https://github.com/fe3dback/go-arch-lint/v1",
"title": "Go Arch Lint V1",
"type": "object",
"description": "Arch file scheme version 1",
"required": ["version", "components", "deps"],
"additionalProperties": false,
"properties": {
"version": {"$ref": "#/definitions/version"},
"allow": {"$ref": "#/definitions/settings"},
"exclude": {"$ref": "#/definitions/exclude"},
"excludeFiles": {"$ref": "#/definitions/excludeFiles"},
"vendors": {"$ref": "#/definitions/vendors"},
"commonVendors": {"$ref": "#/definitions/commonVendors"},
"components": {"$ref": "#/definitions/components"},
"commonComponents": {"$ref": "#/definitions/commonComponents"},
"deps": {"$ref": "#/definitions/dependencies"}
},
"definitions": {
"version": {
"title": "Scheme Version",
"description": "Defines arch file syntax and file validation rules",
"type": "integer",
"minimum": 1,
"maximum": 1
},
"settings": {
"title": "Global Scheme options",
"type": "object",
"additionalProperties": false,
"properties": {
"depOnAnyVendor": {
"title": "Any project file can import any vendor lib",
"type": "boolean"
}
}
},
"exclude": {
"title": "Excluded folders from analyse",
"type": "array",
"items": {
"type": "string",
"title": "relative path to project root"
}
},
"excludeFiles": {
"title": "Excluded files from analyse matched by regexp",
"description": "package will by excluded in all package files is matched by provided regexp's",
"type": "array",
"items": {
"type": "string",
"title": "regular expression for absolute file path matching",
"x-intellij-language-injection": "regexp"
}
},
"vendors": {
"title": "List of vendor libs",
"type": "object",
"additionalProperties": {"$ref": "#/definitions/vendor"}
},
"vendor": {
"type": "object",
"required": ["in"],
"properties": {
"in": {
"title": "full import path to vendor",
"type": "string",
"examples": ["golang.org/x/mod/modfile"]
}
},
"additionalProperties": false
},
"commonVendors": {
"title": "List of vendor names",
"description": "All project packages can import this vendor libs",
"type": "array",
"items": {
"type": "string",
"title": "vendor name"
}
},
"components": {
"title": "List of components",
"type": "object",
"additionalProperties": {"$ref": "#/definitions/component"}
},
"component": {
"type": "object",
"required": ["in"],
"properties": {
"in": {
"title": "relative path to project package",
"description": "can contain glob for search",
"type": "string",
"examples": ["src/services", "src/services/*/repo", "src/*/services/**"]
}
},
"additionalProperties": false
},
"commonComponents": {
"title": "List of components names",
"description": "All project packages can import this components, useful for utils packages like 'models'",
"type": "array",
"items": {
"type": "string",
"title": "component name"
}
},
"dependencies": {
"title": "Dependency rules between spec and package imports",
"type": "object",
"additionalProperties": {"$ref": "#/definitions/dependencyRule"}
},
"dependencyRule": {
"type": "object",
"properties": {
"anyProjectDeps": {
"title": "Allow import any project package?",
"type": "boolean"
},
"anyVendorDeps": {
"title": "Allow import any vendor package?",
"type": "boolean"
},
"mayDependOn": {
"title": "List of allowed components to import",
"type": "array",
"items": {
"type": "string",
"title": "component name"
}
},
"canUse": {
"title": "List of allowed vendors to import",
"type": "array",
"items": {
"type": "string",
"title": "vendor name"
}
}
},
"additionalProperties": false
}
}
}` | internal/schema/v1.go | 0.546012 | 0.47725 | v1.go | starcoder |
package gohome
import (
"github.com/PucklaMotzer09/mathgl/mgl32"
"image/color"
)
const (
SHAPE3D_SHADER_NAME string = "Shape3D"
)
// A 3D shape as a RenderObject
type Shape3D struct {
NilRenderObject
// The name of this shape
Name string
shapeInterface Shape3DInterface
transform TransformableObject
// The transform of this shape
Transform *TransformableObject3D
// Wether this shape is visible
Visible bool
shader Shader
// The index of the camera to which this shape is relative
NotRelativeToCamera int
rtype RenderType
}
// Initialises all values
func (this *Shape3D) Init() {
if ResourceMgr.GetShader(SHAPE3D_SHADER_NAME) == nil {
LoadGeneratedShader3D(SHADER_TYPE_SHAPE3D, 0)
}
this.shapeInterface = Render.CreateShape3DInterface(this.Name)
this.shapeInterface.Init()
this.Transform = &TransformableObject3D{
Scale: [3]float32{1.0, 1.0, 1.0},
Rotation: mgl32.QuatRotate(0.0, mgl32.Vec3{0.0, 1.0, 0.0}),
}
this.transform = this.Transform
this.Visible = true
this.NotRelativeToCamera = -1
this.rtype = TYPE_3D_NORMAL
}
// Add a point to the shape
func (this *Shape3D) AddPoint(point Shape3DVertex) {
this.shapeInterface.AddPoints([]Shape3DVertex{point})
}
// Add multiple points to the shape
func (this *Shape3D) AddPoints(points []Shape3DVertex) {
this.shapeInterface.AddPoints(points)
}
// Add a line to the shape
func (this *Shape3D) AddLine(line Line3D) {
this.shapeInterface.AddPoints(line[:])
}
// Add multiple lines to the shape
func (this *Shape3D) AddLines(lines []Line3D) {
for _, l := range lines {
this.AddLine(l)
}
}
// Add a triangle to the shape
func (this *Shape3D) AddTriangle(tri Triangle3D) {
this.shapeInterface.AddPoints(tri[:])
}
// Add multiple triangles to the shape
func (this *Shape3D) AddTriangles(tris []Triangle3D) {
for _, t := range tris {
this.AddTriangle(t)
}
}
// Set the draw mode (POINTS,LINES,TRIANGLES)
func (this *Shape3D) SetDrawMode(drawMode uint8) {
this.shapeInterface.SetDrawMode(drawMode)
}
// Sets the point size
func (this *Shape3D) SetPointSize(size float32) {
this.shapeInterface.SetPointSize(size)
}
// Sets the line width
func (this *Shape3D) SetLineWidth(width float32) {
this.shapeInterface.SetLineWidth(width)
}
// Loads the data into the GPU
func (this *Shape3D) Load() {
this.shapeInterface.Load()
}
// Sets the color of this shape
func (this *Shape3D) SetColor(col color.Color) {
points := this.shapeInterface.GetPoints()
for _, p := range points {
p.SetColor(col)
}
}
// Returns all points of the shape
func (this *Shape3D) GetPoints() []Shape3DVertex {
return this.shapeInterface.GetPoints()
}
// Calls the draw method on the data
func (this *Shape3D) Render() {
this.shapeInterface.Render()
}
// Sets the shader of this shape
func (this *Shape3D) SetShader(s Shader) {
this.shader = s
}
// Returns the shader of this shape
func (this *Shape3D) GetShader() Shader {
if this.shader == nil {
this.shader = ResourceMgr.GetShader(SHAPE3D_SHADER_NAME)
}
return this.shader
}
// Sets the render type of the shape
func (this *Shape3D) SetType(rtype RenderType) {
this.rtype = rtype
}
// Returns the render type of the shape
func (this *Shape3D) GetType() RenderType {
return this.rtype
}
// Returns wether this shape is visible
func (this *Shape3D) IsVisible() bool {
return this.Visible
}
// Returns the index of the camera to which this shape is not relative to
func (this *Shape3D) NotRelativeCamera() int {
return this.NotRelativeToCamera
}
// Sets the transformable object of this shape
func (this *Shape3D) SetTransformableObject(tobj TransformableObject) {
this.transform = tobj
if tobj != nil {
this.Transform = tobj.(*TransformableObject3D)
} else {
this.Transform = nil
}
}
// Returns the transformable object of this shape
func (this *Shape3D) GetTransformableObject() TransformableObject {
return this.transform
}
// Cleans everything up
func (this *Shape3D) Terminate() {
this.shapeInterface.Terminate()
} | src/gohome/shape3d.go | 0.768299 | 0.557665 | shape3d.go | starcoder |
package paytocontract
import (
"crypto/ecdsa"
"math/big"
"github.com/btcsuite/btcd/btcec"
)
/*
PAY TO CONTRACT DEFINITIONS
KEY PAIR
let (x, P) be a public/private key pair with the public key P given by:
P = x*G (1)
for private key x and elliptic curve generator G
TWEAKED PUBLIC KEY
An altered public key derived from an internal public key P and a non-random
elliptic curve point C = c*G. The equation is as follows:
Q = P + C (2)
Adding the internal public key P to another elliptic curve point C allows
for the encoding of arbitrary data into the tweaked public key through user
selection of c. Most basically, this is useful as it enables us to encode more information
in a single public key and then use this information to provide more "spend-time" flexibility
TWEAKED SECRET
Schnorr signatures spending UTXO locked to the tweaked public key Q can easily be spent
by modifying the original private key x prior to signing. Substitution of (1) into (2)
gives:
Q = x*G + c*G
Q = ( x + c )*G = w*G (3)
with w = (x+c) as the shared secret
*/
var (
// Curve represents the secp256k1 elliptic curve
Curve = btcec.S256()
// N represents the size of the finite cyclic group defined over the given elliptic curve
N = Curve.Params().N
// P represents the prime order of the finite field over which we take the elliptic curve...
P = Curve.Params().P
)
/*
PAY TO CONTRACT METHODS
Define the various methods for implementing Pay to Contract (a Taproot precursor)
Step 1: Determine whether we can tweak a public key - have it commit
to arbitrary data and still produce a valid Schnorr signature (CONFIRMED)
Step 2: Implement the M.A.S.T component of Taproot - The data
to commit to will be the merkle root of this tree
*/
// TweakAdd alters a given public key (P) committing it to arbitrary data and returns
// an elliptic curve point (qX, qY) representing the tweaked key.
// Payments to the tweaked key (Q) commit funds to knowledge of this data.
// For this reason the data is referred to as a contract. The contract is the hash digest
// of the data and is interpreted as a 32-byte big endian integer.
// Under BIP-Taproot the data is itself a commitment in form of a merkle root
// whose leaves are comprised of Bitcoin scripts specifying the various spending
// conditions for the transaction output (see M.A.S.T)
func TweakAdd(publicKey *ecdsa.PublicKey, contract [32]byte) (qX, qY *big.Int) {
// Calculate the contract point C = H(...arbitrary data)*G
cX, cY := Curve.ScalarBaseMult(contract[:])
// Add internal public key to contract point Q = P + c*G
qX, qY = Curve.Add(publicKey.X, publicKey.Y, cX, cY)
return qX, qY
}
// TweakSecretKey computes the modified secret key (w) corresponding to the
// tweaked public Q = w*G which can be used to spend UTXO with a ScriptPubKey
// which commits to a tweaked public key.
// Usage: Modify the original private key (x) prior to signing
func TweakSecretKey(x *big.Int, contract [32]byte) *big.Int {
// Compute the tweaked secret ( x + c )
c := new(big.Int).SetBytes(contract[:])
tweakSecret := new(big.Int)
tweakSecret.Add(x, c)
tweakSecret.Mod(tweakSecret, Curve.N)
return tweakSecret
} | pay_to_contract.go | 0.676834 | 0.509215 | pay_to_contract.go | starcoder |
package reflext
import (
"reflect"
)
// Zeroer :
type Zeroer interface {
IsZero() bool
}
// Init : initialise the first level of reflect.Value
func Init(v reflect.Value) reflect.Value {
if v.Kind() == reflect.Ptr && v.IsNil() {
v.Set(reflect.New(v.Type().Elem()))
}
if v.Kind() == reflect.Map && v.IsNil() {
v.Set(reflect.MakeMap(v.Type()))
}
if v.Kind() == reflect.Slice && v.IsNil() {
v.Set(reflect.MakeSlice(v.Type(), 0, 0))
}
return v
}
// IndirectInit : initialise reflect.Value till the deep level
func IndirectInit(v reflect.Value) reflect.Value {
for v.Kind() == reflect.Ptr {
if v.IsNil() {
v.Set(reflect.New(v.Type().Elem()))
}
v = v.Elem()
}
return v
}
// ValueOf : this is the replacement for reflect.ValueOf()
func ValueOf(i interface{}) reflect.Value {
if x, ok := i.(reflect.Value); ok {
return x
}
return reflect.ValueOf(i)
}
// TypeOf : this is the replacement for reflect.TypeOf()
func TypeOf(i interface{}) reflect.Type {
if x, ok := i.(reflect.Type); ok {
return x
}
return reflect.TypeOf(i)
}
// Deref : this is the replacement for reflect.Elem()
func Deref(t reflect.Type) reflect.Type {
for t.Kind() == reflect.Ptr {
t = t.Elem()
}
return t
}
// Indirect : this is the replacement for reflect.Indirect()
func Indirect(v reflect.Value) reflect.Value {
for v.Kind() == reflect.Ptr {
if v.IsNil() {
break
}
v = v.Elem()
}
return v
}
// IsNull : determine the reflect.Value is null or not
func IsNull(v reflect.Value) bool {
if !v.IsValid() {
return true
}
k := v.Kind()
return (k == reflect.Ptr ||
k == reflect.Slice ||
k == reflect.Map ||
k == reflect.Interface ||
k == reflect.Func) && v.IsNil()
}
// Zero :
func Zero(t reflect.Type) (v reflect.Value) {
v = reflect.New(t)
vi := v.Elem()
for vi.Kind() == reflect.Ptr && vi.IsNil() {
vi.Set(reflect.New(vi.Type().Elem()))
vi = vi.Elem()
}
return v.Elem()
}
// IsNullable : determine whether is nullable data type
func IsNullable(t reflect.Type) bool {
if t == nil {
return true
}
k := t.Kind()
return k == reflect.Ptr ||
k == reflect.Slice ||
k == reflect.Map ||
k == reflect.Interface ||
k == reflect.Func ||
k == reflect.Chan
}
// IsKind : compare and check the respective reflect.Kind
func IsKind(t reflect.Type, k reflect.Kind) bool {
if t == nil {
return k == reflect.Interface
}
return t.Kind() == k
}
/*
IsZero : determine is zero value
1. string => empty string
2. bool => false
3. function => nil
4. map => nil (uninitialized map)
5. slice => nil (uninitialized slice)
*/
func IsZero(v reflect.Value) bool {
if !v.IsValid() {
return true
}
it := v.Interface()
x, ok := it.(Zeroer)
if ok {
return x.IsZero()
}
switch v.Kind() {
case reflect.Interface, reflect.Func:
return v.IsNil()
case reflect.Slice, reflect.Map:
return v.IsNil() || v.Len() == 0
case reflect.Array:
if v.Len() == 0 {
return true
}
z := true
for i := 0; i < v.Len(); i++ {
z = z && IsZero(v.Index(i))
}
return z
case reflect.Struct:
z := true
for i := 0; i < v.NumField(); i++ {
z = z && IsZero(v.Field(i))
}
return z
}
// Compare other types directly:
z := reflect.Zero(v.Type())
return it == z.Interface()
}
// Set :
func Set(src, v reflect.Value) {
IndirectInit(src).Set(v)
} | reflext/helper.go | 0.612078 | 0.482978 | helper.go | starcoder |
package redundant_connection
import "reflect"
/*
684. 冗余连接
https://leetcode-cn.com/problems/redundant-connection
在本问题中, 树指的是一个连通且无环的无向图。
输入一个图，该图由一个有着N个节点 (节点值不重复1, 2, ..., N) 的树及一条附加的边构成。
附加的边的两个顶点包含在1到N中间，这条附加的边不属于树中已存在的边。
结果图是一个以边组成的二维数组。
每一个边的元素是一对[u, v] ，满足 u < v，表示连接顶点u 和v的无向图的边。
返回一条可以删去的边，使得结果图是一个有着N个节点的树。
如果有多个答案，则返回二维数组中最后出现的边。
答案边 [u, v] 应满足相同的格式 u < v。
示例 1：
输入: [[1,2], [1,3], [2,3]]
输出: [2,3]
解释: 给定的无向图为:
1
/ \
2 - 3
示例 2：
输入: [[1,2], [2,3], [3,4], [1,4], [1,5]]
输出: [1,4]
解释: 给定的无向图为:
5 - 1 - 2
| |
4 - 3
注意:
输入的二维数组大小在 3 到 1000。
二维数组中的整数在1到N之间，其中N是输入数组的大小。
更新(2017-09-26):
我们已经重新检查了问题描述及测试用例，明确图是无向图。
对于有向图详见冗余连接II。对于造成任何不便，我们深感歉意。
*/
// Union-Find
func findRedundantConnection(edges [][]int) []int {
uf := make([]int, len(edges)+1)
for i := range uf {
uf[i] = i
}
for _, e := range edges {
if !union(uf, e[0], e[1]) {
return e
}
}
return nil
}
// DFS
func findRedundantConnectionDfs(edges [][]int) []int {
n := len(edges)
graph := make([][]int, n+1)
for _, edge := range edges {
src, dest := edge[0], edge[1]
if len(graph[src]) > 0 && len(graph[dest]) > 0 && isConnected(graph, src, dest, make([]bool, n+1)) {
return edge
}
graph[src] = append(graph[src], dest)
graph[dest] = append(graph[dest], src)
}
return nil
}
func isConnected(graph [][]int, src, dest int, seen []bool) bool {
if seen[src] {
return false
}
if src == dest {
return true
}
seen[src] = true
for _, nei := range graph[src] {
if isConnected(graph, nei, dest, seen) {
return true
}
}
return false
}
/*
685. 冗余连接 II
https://leetcode-cn.com/problems/redundant-connection-ii
在本问题中，有根树指满足以下条件的有向图。
该树只有一个根节点，所有其他节点都是该根节点的后继。每一个节点只有一个父节点，除了根节点没有父节点。
输入一个有向图，该图由一个有着N个节点 (节点值不重复1, 2, ..., N) 的树及一条附加的边构成。
附加的边的两个顶点包含在1到N中间，这条附加的边不属于树中已存在的边。
结果图是一个以边组成的二维数组。
每一个边 的元素是一对 [u, v]，用以表示有向图中连接顶点 u 和顶点 v 的边，其中 u 是 v 的一个父节点。
返回一条能删除的边，使得剩下的图是有N个节点的有根树。若有多个答案，返回最后出现在给定二维数组的答案。
示例 1:
输入: [[1,2], [1,3], [2,3]]
输出: [2,3]
解释: 给定的有向图如下:
1
/ \
v v
2-->3
示例 2:
输入: [[1,2], [2,3], [3,4], [4,1], [1,5]]
输出: [4,1]
解释: 给定的有向图如下:
5 <- 1 -> 2
^ |
| v
4 <- 3
注意:
二维数组大小的在3到1000范围内。
二维数组中的每个整数在1到N之间，其中 N 是二维数组的大小。
*/
/*
如果所有节点最多只有一个父节点，那么解法和上面问题（684）完全一样；即只需找到使图出现环的那条边。
否则，先找到有两个父节点的节点 X，结果就是指向 X 的这两条边里的一条，具体是哪一条？
看两个例子：
1 -> 2
| ^
v /
3
删除 1->2 或 3->2 都可以，根据题意，删除在 edges 数组最后出现的即可
2 -> 1 <- 3
^ /
| V
4
如果删除 3->1， 剩余的图就会有一个环； 所以只能删除 2->1
*/
func findRedundantDirectedConnection(edges [][]int) []int {
// 如果某个节点有两条入边，这两条入边之一就是答案
candidates := [2][]int{}
parent := make([]int, len(edges)+1)
for _, e := range edges {
if parent[e[1]] != 0 {
candidates = [2][]int{{parent[e[1]], e[1]}, {e[0], e[1]}}
break
}
parent[e[1]] = e[0]
}
// 没有有两条入边的节点，只需要找到使图成环的边
if candidates[0] == nil {
return detectCycle(edges, nil)
}
// 在两条候选边，需要确定返回哪一条
if detectCycle(edges, candidates[1]) == nil { // // 忽略第二条候选边没有在图里发现环
return candidates[1]
}
return candidates[0] // 忽略第二条候选边在图里发现了环
}
func detectCycle(edges [][]int, ignore []int) []int {
uf := make([]int, len(edges)+1)
for i := range uf {
uf[i] = i
}
for _, e := range edges {
if reflect.DeepEqual(e, ignore) {
continue
}
if !union(uf, e[0], e[1]) {
return e
}
}
return nil
}
func union(uf []int, x, y int) bool {
xRoot, yRoot := find(uf, x), find(uf, y)
if xRoot == yRoot {
return false
}
uf[xRoot] = uf[yRoot]
return true
}
func find(uf []int, x int) int {
for x != uf[x] {
x, uf[x] = uf[x], uf[uf[x]]
}
return x
} | solutions/redundant-connection/d.go | 0.507324 | 0.598165 | d.go | starcoder |
package main
import (
"fmt"
"math/bits"
"regexp"
"strings"
"github.com/scottyw/adventofcode2020/pkg/aoc"
)
func main() {
input := aoc.FileToString("input/20.txt")
tiles := parseTiles(input)
fmt.Println(findCorners(tiles))
}
func findCorners(tiles map[int][4]uint) int {
// Build a map that lists all tiles with a particular edge
matches := map[uint][]int{}
for id, edges := range tiles {
for _, edge := range edges {
ne := normalize(edge)
matches[ne] = append(matches[ne], id)
}
}
// Count how many unique edges are associated with each ID
counts := map[int]int{}
for _, ids := range matches {
if len(ids) == 1 {
counts[ids[0]]++
}
}
// We're looking for tiles with 2 edges unique to them and
// we cross-check we found exactly four of them
var corners []int
sum := 1
for id, count := range counts {
if count == 2 {
sum *= id
corners = append(corners, id)
}
}
if len(corners) != 4 {
panic(corners)
}
return sum
}
// Normalize an 10-bit edge which can be read forwards or backwards
func normalize(e uint) uint {
r := uint(bits.Reverse16(uint16(e)) >> 6)
if r > e {
return e
}
return r
}
func parseTiles(input string) map[int][4]uint {
tiles := map[int][4]uint{}
for _, tile := range strings.Split(strings.TrimSpace(input), "\n\n") {
id, edges := parseTile(strings.Split(tile, "\n"))
tiles[id] = edges
}
return tiles
}
func parseTile(tile []string) (int, [4]uint) {
if len(tile) != 11 {
panic(fmt.Sprintf("unexpected tile: %v", tile))
}
matches := r.FindStringSubmatch(tile[0])
id := aoc.Atoi(matches[1])
// Convert top edge to uint
var a uint
for _, c := range tile[1] {
a <<= 1
if c == '#' {
a |= 1
}
}
// Convert bottom edge to uint
var b uint
for _, c := range tile[10] {
b <<= 1
if c == '#' {
b |= 1
}
}
// Convert left edge to uint
var l uint
for _, c := range tile[1:] {
l <<= 1
if c[0] == '#' {
l |= 1
}
}
// Convert right edge to uint
var r uint
for _, c := range tile[1:] {
r <<= 1
if c[9] == '#' {
r |= 1
}
}
return id, [4]uint{a, b, l, r}
}
var r = regexp.MustCompile("Tile (\\d+):") | cmd/day20a/main.go | 0.595728 | 0.44089 | main.go | starcoder |
package attester
import (
"context"
"sort"
api "github.com/attestantio/go-eth2-client/api/v1"
"github.com/attestantio/go-eth2-client/spec/phase0"
)
// MergeDuties merges attester duties given by an Ethereum 2 client into vouch's per-slot structure.
func MergeDuties(ctx context.Context, attesterDuties []*api.AttesterDuty) ([]*Duty, error) {
duties := make([]*Duty, 0)
if len(attesterDuties) == 0 {
return duties, nil
}
validatorIndices := make(map[phase0.Slot][]phase0.ValidatorIndex)
committeeIndices := make(map[phase0.Slot][]phase0.CommitteeIndex)
validatorCommitteeIndices := make(map[phase0.Slot][]uint64)
committeeLengths := make(map[phase0.Slot]map[phase0.CommitteeIndex]uint64)
committeesAtSlots := make(map[phase0.Slot]uint64)
// Set the base capacity for our arrays based on the number of attester duties.
// This is much higher than we need, but is overall minimal and avoids reallocations.
arrayCap := uint64(len(attesterDuties))
// Sort the response by slot, then committee index, then validator index.
sort.Slice(attesterDuties, func(i int, j int) bool {
if attesterDuties[i].Slot < attesterDuties[j].Slot {
return true
}
if attesterDuties[i].Slot > attesterDuties[j].Slot {
return false
}
if attesterDuties[i].CommitteeIndex < attesterDuties[j].CommitteeIndex {
return true
}
if attesterDuties[i].CommitteeIndex > attesterDuties[j].CommitteeIndex {
return false
}
return attesterDuties[i].ValidatorIndex < attesterDuties[j].ValidatorIndex
})
for _, duty := range attesterDuties {
// Future optimisation (maybe; depends how much effort it is to fetch validator status here):
// There are three states where a validator is given duties: active, exiting and slashing.
// However, if the validator is slashing its attestations are ignored by the network.
// Hence, if the validator is slashed we don't need to include its duty.
_, exists := validatorIndices[duty.Slot]
if !exists {
validatorIndices[duty.Slot] = make([]phase0.ValidatorIndex, 0, arrayCap)
committeeIndices[duty.Slot] = make([]phase0.CommitteeIndex, 0, arrayCap)
committeeLengths[duty.Slot] = make(map[phase0.CommitteeIndex]uint64)
committeesAtSlots[duty.Slot] = duty.CommitteesAtSlot
}
committeesAtSlots[duty.Slot] = duty.CommitteesAtSlot
validatorIndices[duty.Slot] = append(validatorIndices[duty.Slot], duty.ValidatorIndex)
committeeIndices[duty.Slot] = append(committeeIndices[duty.Slot], duty.CommitteeIndex)
committeeLengths[duty.Slot][duty.CommitteeIndex] = duty.CommitteeLength
validatorCommitteeIndices[duty.Slot] = append(validatorCommitteeIndices[duty.Slot], duty.ValidatorCommitteeIndex)
}
for slot := range validatorIndices {
if duty, err := NewDuty(
ctx,
slot,
committeesAtSlots[slot],
validatorIndices[slot],
committeeIndices[slot],
validatorCommitteeIndices[slot],
committeeLengths[slot],
); err == nil {
duties = append(duties, duty)
}
}
// Order the attester duties by slot.
sort.Slice(duties, func(i int, j int) bool {
if duties[i].Slot() < duties[j].Slot() {
return true
}
if duties[i].Slot() > duties[j].Slot() {
return false
}
return true
})
return duties, nil
} | services/attester/helpers.go | 0.585575 | 0.409044 | helpers.go | starcoder |
package terminal
import (
"context"
"runtime"
"sync"
"github.com/searKing/golang/go/error/exception"
"github.com/searKing/golang/go/util/class"
"github.com/searKing/golang/go/util/spliterator"
)
type Task interface {
GetSpliterator() spliterator.Spliterator
/**
* Returns the parent of this task, or null if this task is the root
*
* @return the parent of this task, or null if this task is the root
*/
GetParent() Task
/**
* The left child.
* null if no children
* if non-null rightChild is non-null
*
* @return the right child
*/
LeftChild() Task
SetLeftChild(task Task)
/**
* The right child.
* null if no children
* if non-null rightChild is non-null
*
* @return the right child
*/
RightChild() Task
SetRightChild(task Task)
/**
* Indicates whether this task is a leaf node. (Only valid after
* {@link #compute} has been called on this node). If the node is not a
* leaf node, then children will be non-null and numChildren will be
* positive.
*
* @return {@code true} if this task is a leaf node
*/
IsLeaf() bool
/**
* Indicates whether this task is the root node
*
* @return {@code true} if this task is the root node.
*/
IsRoot() bool
/**
* Target leaf size, common to all tasks in a computation
*
* @return target leaf size.
*/
TargetSize() int
/**
* Default target of leaf tasks for parallel decomposition.
* To allow load balancing, we over-partition, currently to approximately
* four tasks per processor, which enables others to help out
* if leaf tasks are uneven or some processors are otherwise busy.
*
* @return the default target size of leaf tasks
*/
GetLeafTarget() int
/**
* Constructs a new node of type T whose parent is the receiver; must call
* the TODOTask(T, Spliterator) constructor with the receiver and the
* provided Spliterator.
*
* @param spliterator {@code Spliterator} describing the subtree rooted at
* this node, obtained by splitting the parent {@code Spliterator}
* @return newly constructed child node
*/
MakeChild(spliterator spliterator.Spliterator) Task
/**
* Computes the result associated with a leaf node. Will be called by
* {@code compute()} and the result passed to @{code setLocalResult()}
*
* @return the computed result of a leaf node
*/
DoLeaf(ctx context.Context) Sink
/**
* Retrieves a result previously stored with {@link #setLocalResult}
*
* @return local result for this node previously stored with
* {@link #setLocalResult}
*/
GetLocalResult() Sink
/**
* Associates the result with the task, can be retrieved with
* {@link #GetLocalResult}
*
* @param localResult local result for this node
*/
SetLocalResult(localResult Sink)
/**
* Decides whether or not to split a task further or compute it
* directly. If computing directly, calls {@code doLeaf} and pass
* the result to {@code setRawResult}. Otherwise splits off
* subtasks, forking one and continuing as the other.
*
* <p> The method is structured to conserve resources across a
* range of uses. The loop continues with one of the child tasks
* when split, to avoid deep recursion. To cope with spliterators
* that may be systematically biased toward left-heavy or
* right-heavy splits, we alternate which child is forked versus
* continued in the loop.
*/
Compute(ctx context.Context)
/**
* {@inheritDoc}
*
* @implNote
* Clears spliterator and children fields. Overriders MUST call
* {@code super.onCompletion} as the last thing they do if they want these
* cleared.
*/
OnCompletion(caller Task)
/**
* Returns whether this node is a "leftmost" node -- whether the path from
* the root to this node involves only traversing leftmost child links. For
* a leaf node, this means it is the first leaf node in the encounter order.
*
* @return {@code true} if this node is a "leftmost" node
*/
IsLeftmostNode() bool
/**
* Arranges to asynchronously execute this task in the pool the
* current task is running in, if applicable, or using the {@link
* ForkJoinPool#commonPool()} if not {@link #inForkJoinPool}. While
* it is not necessarily enforced, it is a usage error to fork a
* task more than once unless it has completed and been
* reinitialized. Subsequent modifications to the state of this
* task or any data it operates on are not necessarily
* consistently observable by any thread other than the one
* executing it unless preceded by a call to {@link #join} or
* related methods, or a call to {@link #isDone} returning {@code
* true}.
*
* @return {@code this}, to simplify usage
*/
Fork(ctx context.Context)
/**
* Returns the result of the computation when it
* {@linkplain #isDone is done}.
* This method differs from {@link #get()} in that abnormal
* completion results in {@code RuntimeException} or {@code Error},
* not {@code ExecutionException}, and that interrupts of the
* calling thread do <em>not</em> cause the method to abruptly
* return by throwing {@code InterruptedException}.
*
* @return the computed result
*/
Join() Sink
/**
* Commences performing this task, awaits its completion if
* necessary, and returns its result, or throws an (unchecked)
* {@code RuntimeException} or {@code Error} if the underlying
* computation did so.
*
* @return the computed result
*/
Invoke(ctx context.Context) Sink
}
type TODOTask struct {
class.Class
parent Task
/**
* The spliterator for the portion of the input associated with the subtree
* rooted at this task
*/
spliterator spliterator.Spliterator
/** Target leaf size, common to all tasks in a computation */
targetSize int // may be lazily initialized
/**
* The left child.
* null if no children
* if non-null rightChild is non-null
*/
leftChild Task
/**
* The right child.
* null if no children
* if non-null leftChild is non-null
*/
rightChild Task
/** The result of this node, if completed */
localResult Sink
computer func(ctx context.Context)
wg sync.WaitGroup
}
/**
* Constructor for root nodes.
*
* @param helper The {@code PipelineHelper} describing the stream pipeline
* up to this operation
* @param spliterator The {@code Spliterator} describing the source for this
* pipeline
*/
func (task *TODOTask) WithSpliterator(spliterator spliterator.Spliterator) *TODOTask {
task.spliterator = spliterator
return task
}
/**
* Constructor for non-root nodes.
*
* @param parent this node's parent task
* @param spliterator {@code Spliterator} describing the subtree rooted at
* this node, obtained by splitting the parent {@code Spliterator}
*/
func (task *TODOTask) WithParent(parent Task, spliterator spliterator.Spliterator) *TODOTask {
task.parent = parent
task.spliterator = spliterator
task.targetSize = parent.TargetSize()
return task
}
func (task *TODOTask) GetSpliterator() spliterator.Spliterator {
return task.spliterator
}
func (task *TODOTask) GetLeafTarget() int {
return runtime.GOMAXPROCS(-1) << 2
}
func (task *TODOTask) LeftChild() Task {
return task.leftChild
}
func (task *TODOTask) SetLeftChild(task_ Task) {
task.leftChild = task_
}
func (task *TODOTask) RightChild() Task {
return task.rightChild
}
func (task *TODOTask) SetRightChild(task_ Task) {
task.rightChild = task_
}
func (task *TODOTask) TargetSize() int {
return task.targetSize
}
func (task *TODOTask) MakeChild(spliterator spliterator.Spliterator) Task {
panic(exception.NewUnsupportedOperationException())
return nil
}
func (task *TODOTask) DoLeaf(ctx context.Context) Sink {
panic(exception.NewUnsupportedOperationException())
return nil
}
/**
* Returns a suggested target leaf size based on the initial size estimate.
*
* @return suggested target leaf size
*/
func (task *TODOTask) suggestTargetSize(sizeEstimate int) int {
this := task.GetDerivedElse(task).(Task)
est := sizeEstimate / this.GetLeafTarget()
if est > 0 {
return est
}
return 1
}
/**
* Returns the targetSize, initializing it via the supplied
* size estimate if not already initialized.
*/
func (task *TODOTask) getTargetSize(sizeEstimate int) int {
if task.targetSize != 0 {
return task.targetSize
}
task.targetSize = task.suggestTargetSize(sizeEstimate)
return task.targetSize
}
/**
* Returns the local result, if any. Subclasses should use
* {@link #setLocalResult(Object)} and {@link #GetLocalResult()} to manage
* results. This returns the local result so that calls from within the
* fork-join framework will return the correct result.
*
* @return local result for this node previously stored with
* {@link #setLocalResult}
*/
func (task *TODOTask) getRawResult() Sink {
return task.localResult
}
/**
* Does nothing; instead, subclasses should use
* {@link #setLocalResult(Object)}} to manage results.
*
* @param result must be null, or an exception is thrown (this is a safety
* tripwire to detect when {@code setRawResult()} is being used
* instead of {@code setLocalResult()}
*/
func (task *TODOTask) SetRawResult(result Sink) {
if result != nil {
panic(exception.NewIllegalStateException())
}
}
/**
* Retrieves a result previously stored with {@link #setLocalResult}
*
* @return local result for this node previously stored with
* {@link #setLocalResult}
*/
func (task *TODOTask) GetLocalResult() Sink {
return task.localResult
}
/**
* Associates the result with the task, can be retrieved with
* {@link #GetLocalResult}
*
* @param localResult local result for this node
*/
func (task *TODOTask) SetLocalResult(localResult Sink) {
task.localResult = localResult
}
func (task *TODOTask) IsLeaf() bool {
return task.leftChild == nil
}
func (task *TODOTask) IsRoot() bool {
this := task.GetDerivedElse(task).(Task)
return this.GetParent() == nil
}
func (task *TODOTask) GetParent() Task {
return task.parent
}
func (task *TODOTask) Compute(ctx context.Context) {
rs := task.spliterator
var ls spliterator.Spliterator
sizeEstimate := rs.EstimateSize()
sizeThreshold := task.getTargetSize(sizeEstimate)
var this = task.GetDerivedElse(task).(Task)
var forkRight bool
for {
select {
case <-ctx.Done():
return
default:
}
if sizeEstimate <= sizeThreshold {
break
}
ls = rs.TrySplit()
if ls == nil {
break
}
var leftChild, rightChild, taskToFork Task
leftChild = this.MakeChild(ls)
rightChild = this.MakeChild(rs)
this.SetLeftChild(leftChild)
this.SetRightChild(rightChild)
if forkRight {
forkRight = false
rs = ls
this = leftChild
taskToFork = rightChild
} else {
forkRight = true
this = rightChild
taskToFork = leftChild
}
// fork
taskToFork.Fork(ctx)
sizeEstimate = rs.EstimateSize()
}
this.SetLocalResult(this.DoLeaf(ctx))
}
func (task *TODOTask) Fork(ctx context.Context) {
go func() {
task.wg.Add(1)
defer task.wg.Done()
this := task.GetDerivedElse(task).(Task)
this.Compute(ctx)
this.OnCompletion(task.GetDerivedElse(task).(Task))
}()
}
func (task *TODOTask) Join() Sink {
task.wg.Wait()
return task.getRawResult()
}
func (task *TODOTask) Invoke(ctx context.Context) Sink {
this := task.GetDerivedElse(task).(Task)
this.Fork(ctx)
return this.Join()
}
func (task *TODOTask) OnCompletion(caller Task) {
task.spliterator = nil
task.leftChild = nil
task.rightChild = nil
}
func (task *TODOTask) IsLeftmostNode() bool {
var node = task.GetDerivedElse(task).(Task)
for node != nil {
parent := node.GetParent()
if parent != nil && parent.LeftChild() != node {
return false
}
node = parent
}
return true
} | go/container/stream/op/terminal/task.go | 0.781372 | 0.420064 | task.go | starcoder |
package treepalette
import (
"image"
"image/color"
"sort"
)
// paletted wraps A source image into A 'paletted' image.
type paletted struct {
src image.Image // src original image
p *Palette
}
func (i *paletted) ColorModel() color.Model {
return i.p
}
func (i *paletted) Bounds() image.Rectangle {
return i.src.Bounds()
}
func (i *paletted) At(x, y int) color.Color {
c := ColorRGBA{AlphaChannel: i.p.alpha}
c.R, c.G, c.B, c.A = i.src.At(x, y).RGBA()
return i.p.Convert(c)
}
func (i *paletted) ColorIndexAt(x, y int) int {
c := ColorRGBA{AlphaChannel: i.p.alpha}
c.R, c.G, c.B, c.A = i.src.At(x, y).RGBA()
return i.p.ConvertColor(c).Index()
}
// ApplyPalette applies the palette onto A given image and returns new image with Palette as color.Model.
func (t *Palette) ApplyPalette(img image.Image) image.Image {
return &paletted{
src: img,
p: t,
}
}
// Rank ranks the colors in the Palette based on counts of pixels of each PaletteColor in the given image.
// Returns A rank list of colors(most occurrences first) and A map with count of pixels for each color index.
func (t *Palette) Rank(img image.Image) ([]PaletteColor, map[int]int) {
count := make(map[int]int)
var colors []PaletteColor
pImg := &paletted{
src: img,
p: t,
}
b := img.Bounds()
for y := 0; y < b.Dy(); y++ {
for x := 0; x < b.Dx(); x++ {
index := pImg.ColorIndexAt(x, y)
_, ok := count[index]
if !ok {
colors = append(colors, t.lookup[index])
}
count[index]++
}
}
sort.Slice(colors, func(i, j int) bool {
return count[colors[i].Index()] > count[colors[j].Index()]
})
return colors, count
}
// RankByIndex ranks the colors in the Palette based on counts of pixels of each PaletteColor in the given image.
// Returns A rank list of color indexes(most occurrences first) and A map with count of pixels for each color index.
func (t *Palette) RankByIndex(img image.Image) ([]int, map[int]int) {
count := make(map[int]int)
var colors []int
pImg := &paletted{
src: img,
p: t,
}
b := img.Bounds()
for y := 0; y < b.Dy(); y++ {
for x := 0; x < b.Dx(); x++ {
index := pImg.ColorIndexAt(x, y)
_, ok := count[index]
if !ok {
colors = append(colors, index)
}
count[index]++
}
}
sort.Slice(colors, func(i, j int) bool {
return count[colors[i]] > count[colors[j]]
})
return colors, count
} | image.go | 0.829975 | 0.469885 | image.go | starcoder |
package parser
import "github.com/pkg/errors"
type resultingTypeDeclarations interface {
ResultingTypeDeclarations() ([]*TypeDeclaration, error)
}
type baseExpression struct {
nodeSource
typeDeclarations []*TypeDeclaration
}
type dualInputExpression struct {
baseExpression
Left Expression
Right Expression
}
type dualInputBoolOutputExpression struct {
dualInputExpression
}
type IntegerLiteralExpression struct {
baseExpression
Value int
}
type CharacterLiteralExpression struct {
baseExpression
Value byte
}
type StringLiteralExpression struct {
baseExpression
Value string
}
type BooleanLiteralExpression struct {
baseExpression
Value bool
}
type IdentifierExpression struct {
baseExpression
IdentifierDeclaration Declaration
}
type AddExpression struct {
dualInputExpression
}
type SubtractExpression struct {
dualInputExpression
}
type MultiplyExpression struct {
dualInputExpression
}
type DivideExpression struct {
dualInputExpression
}
type EqualExpression struct {
dualInputBoolOutputExpression
}
type NotEqualExpression struct {
dualInputBoolOutputExpression
}
type LessExpression struct {
dualInputBoolOutputExpression
}
type LessOrEqualExpression struct {
dualInputBoolOutputExpression
}
type GreaterExpression struct {
dualInputBoolOutputExpression
}
type GreaterOrEqualExpression struct {
dualInputBoolOutputExpression
}
type AndExpression struct {
dualInputBoolOutputExpression
}
type OrExpression struct {
dualInputBoolOutputExpression
}
type NotExpression struct {
baseExpression
Expression Expression
}
type FunctionCallExpression struct {
baseExpression
CallSource Expression // Expression representing a function that can be called.
Parameters []Expression
}
func newBaseExpression(source nodeSource, d ...*TypeDeclaration) baseExpression {
return baseExpression{
nodeSource: source,
typeDeclarations: d,
}
}
func newIntegerLiteralExpression(source nodeSource, value int, scope Scope) *IntegerLiteralExpression {
return &IntegerLiteralExpression{
baseExpression: newBaseExpression(source, scope.SearchTypeDeclaration("Int")),
Value: value,
}
}
func newCharacterLiteralExpression(source nodeSource, value byte, scope Scope) *CharacterLiteralExpression {
return &CharacterLiteralExpression{
baseExpression: newBaseExpression(source, scope.SearchTypeDeclaration("Byte")),
Value: value,
}
}
func newStringLiteralExpression(source nodeSource, value string, scope Scope) *StringLiteralExpression {
return &StringLiteralExpression{
baseExpression: newBaseExpression(source, scope.SearchTypeDeclaration("String")),
Value: value,
}
}
func newBooleanLiteralExpression(source nodeSource, value bool, scope Scope) *BooleanLiteralExpression {
return &BooleanLiteralExpression{
baseExpression: newBaseExpression(source, scope.SearchTypeDeclaration("Bool")),
Value: value,
}
}
func newIdentifierExpression(source nodeSource, declaration Declaration) *IdentifierExpression {
return &IdentifierExpression{
baseExpression: newBaseExpression(source),
IdentifierDeclaration: declaration,
}
}
func newAddExpression(source nodeSource, left Expression, right Expression) *AddExpression {
return &AddExpression{
dualInputExpression: dualInputExpression{
baseExpression: newBaseExpression(source),
Left: left,
Right: right,
},
}
}
func newSubtractExpression(source nodeSource, left Expression, right Expression) *SubtractExpression {
return &SubtractExpression{
dualInputExpression: dualInputExpression{
baseExpression: newBaseExpression(source),
Left: left,
Right: right,
},
}
}
func newMultiplyExpression(source nodeSource, left Expression, right Expression) *MultiplyExpression {
return &MultiplyExpression{
dualInputExpression: dualInputExpression{
baseExpression: newBaseExpression(source),
Left: left,
Right: right,
},
}
}
func newDivideExpression(source nodeSource, left Expression, right Expression) *DivideExpression {
return &DivideExpression{
dualInputExpression: dualInputExpression{
baseExpression: newBaseExpression(source),
Left: left,
Right: right,
},
}
}
func newEqualExpression(source nodeSource, left Expression, right Expression, scope Scope) *EqualExpression {
return &EqualExpression{
dualInputBoolOutputExpression: dualInputBoolOutputExpression{
dualInputExpression: dualInputExpression{
baseExpression: newBaseExpression(source, scope.SearchTypeDeclaration("Bool")),
Left: left,
Right: right,
},
},
}
}
func newNotEqualExpression(source nodeSource, left Expression, right Expression, scope Scope) *NotEqualExpression {
return &NotEqualExpression{
dualInputBoolOutputExpression: dualInputBoolOutputExpression{
dualInputExpression: dualInputExpression{
baseExpression: newBaseExpression(source, scope.SearchTypeDeclaration("Bool")),
Left: left,
Right: right,
},
},
}
}
func newLessExpression(source nodeSource, left Expression, right Expression, scope Scope) *LessExpression {
return &LessExpression{
dualInputBoolOutputExpression: dualInputBoolOutputExpression{
dualInputExpression: dualInputExpression{
baseExpression: newBaseExpression(source, scope.SearchTypeDeclaration("Bool")),
Left: left,
Right: right,
},
},
}
}
func newLessOrEqualExpression(source nodeSource, left Expression, right Expression, scope Scope) *LessOrEqualExpression {
return &LessOrEqualExpression{
dualInputBoolOutputExpression: dualInputBoolOutputExpression{
dualInputExpression: dualInputExpression{
baseExpression: newBaseExpression(source, scope.SearchTypeDeclaration("Bool")),
Left: left,
Right: right,
},
},
}
}
func newGreaterExpression(source nodeSource, left Expression, right Expression, scope Scope) *GreaterExpression {
return &GreaterExpression{
dualInputBoolOutputExpression: dualInputBoolOutputExpression{
dualInputExpression: dualInputExpression{
baseExpression: newBaseExpression(source, scope.SearchTypeDeclaration("Bool")),
Left: left,
Right: right,
},
},
}
}
func newGreaterOrEqualExpression(source nodeSource, left Expression, right Expression, scope Scope) *GreaterOrEqualExpression {
return &GreaterOrEqualExpression{
dualInputBoolOutputExpression: dualInputBoolOutputExpression{
dualInputExpression: dualInputExpression{
baseExpression: newBaseExpression(source, scope.SearchTypeDeclaration("Bool")),
Left: left,
Right: right,
},
},
}
}
func newAndExpression(source nodeSource, left Expression, right Expression, scope Scope) *AndExpression {
return &AndExpression{
dualInputBoolOutputExpression: dualInputBoolOutputExpression{
dualInputExpression: dualInputExpression{
baseExpression: newBaseExpression(source, scope.SearchTypeDeclaration("Bool")),
Left: left,
Right: right,
},
},
}
}
func newOrExpression(source nodeSource, left Expression, right Expression, scope Scope) *OrExpression {
return &OrExpression{
dualInputBoolOutputExpression: dualInputBoolOutputExpression{
dualInputExpression: dualInputExpression{
baseExpression: newBaseExpression(source, scope.SearchTypeDeclaration("Bool")),
Left: left,
Right: right,
},
},
}
}
func newNotExpression(source nodeSource, exp Expression, scope Scope) *NotExpression {
return &NotExpression{
baseExpression: newBaseExpression(source, scope.SearchTypeDeclaration("Bool")),
Expression: exp,
}
}
func newFunctionCallExpression(source nodeSource, callSource Expression, parameters []Expression) *FunctionCallExpression {
return &FunctionCallExpression{
baseExpression: newBaseExpression(source),
CallSource: callSource,
Parameters: parameters,
}
}
func (e *IdentifierExpression) ResultingTypeDeclarations() ([]*TypeDeclaration, error) {
if len(e.baseExpression.typeDeclarations) != 0 {
return e.baseExpression.typeDeclarations, nil
}
switch d := e.IdentifierDeclaration.(type) {
case *VariableDeclaration:
e.baseExpression.typeDeclarations = []*TypeDeclaration{d.TypeDeclaration}
return e.baseExpression.typeDeclarations, nil
case *FunctionDeclaration:
tds := make([]*TypeDeclaration, 0)
fields := d.FunctionDefinition.FunctionType.ReturnTypes
for _, f := range fields {
tds = append(tds, f.VariableDeclaration.TypeDeclaration)
}
e.baseExpression.typeDeclarations = tds
return tds, nil
default:
return nil, errors.New("compiler error: unknown declaration for identifier expression")
}
}
func (e *NotExpression) ResultingTypeDeclarations() ([]*TypeDeclaration, error) {
tds, err := MustSingleReturnType(e.Expression)
if err != nil {
return nil, err
}
if len(e.baseExpression.typeDeclarations) != 1 {
return nil, errors.Errorf("compiler error: expression must have 1 return type but had %d", len(tds))
}
if tds[0] != e.baseExpression.typeDeclarations[0] {
return nil, errors.Errorf("can only use 'not' operator on type Bool, type %s given on line %d column %d",
tds[0].Type.TypeName(), e.UFSourceLine(), e.UFSourceColumn())
}
return tds, nil
}
func (e *FunctionCallExpression) ResultingTypeDeclarations() ([]*TypeDeclaration, error) {
if len(e.typeDeclarations) != 0 {
return e.typeDeclarations, nil
}
idExp, ok := e.CallSource.(*IdentifierExpression)
if !ok {
// TODO change when function-as-first-citizen calling is implemented
return nil, errors.New("compiler error: FunctionCallExpression.CallSource is not an IdentifierExpression")
}
decl, ok := idExp.IdentifierDeclaration.(*FunctionDeclaration)
if !ok {
// TODO change when function-as-first-citizen calling is implemented
return nil, errors.Errorf("cannot call identifier as a function on line %d column %d", e.UFSourceLine(), e.UFSourceColumn())
}
funcType := decl.FunctionDefinition.FunctionType
funcParams := funcType.Parameters
numFuncParams := len(funcParams)
numGivenParams := len(e.Parameters)
if numGivenParams != numFuncParams {
return nil, errors.Errorf("number of parameters mismatch: expected %d but was given %d on line %d column %d",
numFuncParams, numGivenParams, e.UFSourceLine(), e.UFSourceColumn())
}
for i, exp := range e.Parameters {
givenTypeArr, err := MustSingleReturnType(exp)
if err != nil {
return nil, err
}
givenType := givenTypeArr[0]
expectedType := funcParams[i].VariableDeclaration.TypeDeclaration
if givenType != expectedType {
return nil, errors.Errorf("parameter type mismatch: expected '%s' but was given '%d' on line %d column %d",
expectedType.Type.TypeName(), givenType.Type.TypeName(), exp.UFSourceLine(), exp.UFSourceColumn())
}
}
resultTypes := make([]*TypeDeclaration, 0)
for _, f := range funcType.ReturnTypes {
resultTypes = append(resultTypes, f.VariableDeclaration.TypeDeclaration)
}
e.typeDeclarations = resultTypes
return resultTypes, nil
}
func (e baseExpression) ResultingTypeDeclarations() ([]*TypeDeclaration, error) {
if len(e.typeDeclarations) == 0 {
return nil, errors.New("compiler error: baseExpression.typeDeclarations was empty")
}
return e.typeDeclarations, nil
}
func (e dualInputExpression) ResultingTypeDeclarations() ([]*TypeDeclaration, error) {
if len(e.baseExpression.typeDeclarations) != 0 {
return e.baseExpression.typeDeclarations, nil
}
tds1, err := MustSingleReturnType(e.Left)
if err != nil {
return nil, err
}
tds2, err := MustSingleReturnType(e.Right)
if err != nil {
return nil, err
}
if tds1[0] != tds2[0] {
return nil, errors.Errorf("cannot operate for different types, '%s' and '%s', on line %d column %d",
tds1[0].Type.TypeName(), tds2[0].Type.TypeName(), e.UFSourceLine(), e.UFSourceColumn())
}
e.baseExpression.typeDeclarations = tds1
return tds1, nil
}
func (e dualInputBoolOutputExpression) ResultingTypeDeclarations() ([]*TypeDeclaration, error) {
tds, err := MustSingleReturnType(e.dualInputExpression)
if err != nil {
return nil, err
}
if len(e.baseExpression.typeDeclarations) != 1 {
return nil, errors.Errorf("compiler error: expression must have 1 return type but had %d", len(tds))
}
return e.baseExpression.typeDeclarations, nil
}
func MustSingleReturnType(expression resultingTypeDeclarations) ([]*TypeDeclaration, error) {
tds, err := expression.ResultingTypeDeclarations()
if err != nil {
return nil, err
}
if len(tds) != 1 {
return nil, errors.Errorf("compiler error: expression must have 1 return type but had %d", len(tds))
}
return tds, nil
}
func (*IntegerLiteralExpression) exprNode() {}
func (*CharacterLiteralExpression) exprNode() {}
func (*StringLiteralExpression) exprNode() {}
func (*BooleanLiteralExpression) exprNode() {}
func (*IdentifierExpression) exprNode() {}
func (*AddExpression) exprNode() {}
func (*SubtractExpression) exprNode() {}
func (*MultiplyExpression) exprNode() {}
func (*DivideExpression) exprNode() {}
func (*EqualExpression) exprNode() {}
func (*NotEqualExpression) exprNode() {}
func (*LessExpression) exprNode() {}
func (*LessOrEqualExpression) exprNode() {}
func (*GreaterExpression) exprNode() {}
func (*GreaterOrEqualExpression) exprNode() {}
func (*AndExpression) exprNode() {}
func (*OrExpression) exprNode() {}
func (*NotExpression) exprNode() {}
func (*FunctionCallExpression) exprNode() {}
func (*FunctionCallExpression) stmtNode() {} | parser/ast_expression.go | 0.722135 | 0.403273 | ast_expression.go | starcoder |
package canvas
type CanvasCompositeOperationsRule int
var CanvasCompositeOperationsRules = [...]string{
"",
"source-over",
"source-atop",
"source-in",
"source-out",
"destination-over",
"destination-atop",
"destination-in",
"destination-out",
"lighter",
"copy",
"xor",
}
func (el CanvasCompositeOperationsRule) String() string {
return CanvasCompositeOperationsRules[el]
}
const (
// en: Default. Displays the source image over the destination image
KCompositeOperationsRuleSourceOver CanvasCompositeOperationsRule = iota + 1
// en: Displays the source image on top of the destination image. The part of the source image that is outside the
// destination image is not shown
KCompositeOperationsRuleSourceAtop
// en: Displays the source image in to the destination image. Only the part of the source image that is INSIDE the
// destination image is shown, and the destination image is transparent
KCompositeOperationsRuleSourceIn
// en: Displays the source image out of the destination image. Only the part of the source image that is OUTSIDE the
// destination image is shown, and the destination image is transparent
KCompositeOperationsRuleSourceOut
// en: Displays the destination image over the source image
KCompositeOperationsRuleDestinationOver
// en: Displays the destination image on top of the source image. The part of the destination image that is outside
// the source image is not shown
KCompositeOperationsRuleDestinationAtop
// en: Displays the destination image in to the source image. Only the part of the destination image that is INSIDE
// the source image is shown, and the source image is transparent
KCompositeOperationsRuleDestinationIn
// en: Displays the destination image out of the source image. Only the part of the destination image that is OUTSIDE
// the source image is shown, and the source image is transparent
KCompositeOperationsRuleDestinationOut
// en: Displays the source image + the destination image
KCompositeOperationsRuleLighter
// en: Displays the source image. The destination image is ignored
KCompositeOperationsRuleCopy
// en: The source image is combined by using an exclusive OR with the destination image
KCompositeOperationsRuleXor
) | _canvas/typeCompositeOperationsRule.go | 0.675122 | 0.447762 | typeCompositeOperationsRule.go | starcoder |
package msgraph
// RatingCanadaMoviesType undocumented
type RatingCanadaMoviesType string
const (
// RatingCanadaMoviesTypeVAllAllowed undocumented
RatingCanadaMoviesTypeVAllAllowed RatingCanadaMoviesType = "AllAllowed"
// RatingCanadaMoviesTypeVAllBlocked undocumented
RatingCanadaMoviesTypeVAllBlocked RatingCanadaMoviesType = "AllBlocked"
// RatingCanadaMoviesTypeVGeneral undocumented
RatingCanadaMoviesTypeVGeneral RatingCanadaMoviesType = "General"
// RatingCanadaMoviesTypeVParentalGuidance undocumented
RatingCanadaMoviesTypeVParentalGuidance RatingCanadaMoviesType = "ParentalGuidance"
// RatingCanadaMoviesTypeVAgesAbove14 undocumented
RatingCanadaMoviesTypeVAgesAbove14 RatingCanadaMoviesType = "AgesAbove14"
// RatingCanadaMoviesTypeVAgesAbove18 undocumented
RatingCanadaMoviesTypeVAgesAbove18 RatingCanadaMoviesType = "AgesAbove18"
// RatingCanadaMoviesTypeVRestricted undocumented
RatingCanadaMoviesTypeVRestricted RatingCanadaMoviesType = "Restricted"
)
// RatingCanadaMoviesTypePAllAllowed returns a pointer to RatingCanadaMoviesTypeVAllAllowed
func RatingCanadaMoviesTypePAllAllowed() *RatingCanadaMoviesType {
v := RatingCanadaMoviesTypeVAllAllowed
return &v
}
// RatingCanadaMoviesTypePAllBlocked returns a pointer to RatingCanadaMoviesTypeVAllBlocked
func RatingCanadaMoviesTypePAllBlocked() *RatingCanadaMoviesType {
v := RatingCanadaMoviesTypeVAllBlocked
return &v
}
// RatingCanadaMoviesTypePGeneral returns a pointer to RatingCanadaMoviesTypeVGeneral
func RatingCanadaMoviesTypePGeneral() *RatingCanadaMoviesType {
v := RatingCanadaMoviesTypeVGeneral
return &v
}
// RatingCanadaMoviesTypePParentalGuidance returns a pointer to RatingCanadaMoviesTypeVParentalGuidance
func RatingCanadaMoviesTypePParentalGuidance() *RatingCanadaMoviesType {
v := RatingCanadaMoviesTypeVParentalGuidance
return &v
}
// RatingCanadaMoviesTypePAgesAbove14 returns a pointer to RatingCanadaMoviesTypeVAgesAbove14
func RatingCanadaMoviesTypePAgesAbove14() *RatingCanadaMoviesType {
v := RatingCanadaMoviesTypeVAgesAbove14
return &v
}
// RatingCanadaMoviesTypePAgesAbove18 returns a pointer to RatingCanadaMoviesTypeVAgesAbove18
func RatingCanadaMoviesTypePAgesAbove18() *RatingCanadaMoviesType {
v := RatingCanadaMoviesTypeVAgesAbove18
return &v
}
// RatingCanadaMoviesTypePRestricted returns a pointer to RatingCanadaMoviesTypeVRestricted
func RatingCanadaMoviesTypePRestricted() *RatingCanadaMoviesType {
v := RatingCanadaMoviesTypeVRestricted
return &v
} | v1.0/RatingCanadaMoviesTypeEnum.go | 0.59796 | 0.436742 | RatingCanadaMoviesTypeEnum.go | starcoder |
Package parser contains a ECAL parser.
Lexer for Source Text
Lex() is a lexer function to convert a given search query into a list of tokens.
Based on a talk by <NAME>: Lexical Scanning in Go
https://www.youtube.com/watch?v=HxaD_trXwRE
The lexer's output is pushed into a channel which is consumed by the parser.
This design enables the concurrent processing of the input text by lexer and
parser.
Parser
Parse() is a parser which produces a parse tree from a given set of lexer tokens.
Based on an article by <NAME>: Top Down Operator Precedence
http://crockford.com/javascript/tdop/tdop.html
which is based on the ideas of <NAME> and his paper: Top Down Operator Precedence
http://portal.acm.org/citation.cfm?id=512931
https://tdop.github.io/
ParseWithRuntime() parses a given input and decorates the resulting parse tree
with runtime components which can be used to interpret the parsed query.
*/
package parser
/*
LexTokenID represents a unique lexer token ID
*/
type LexTokenID int
/*
Available meta data types
*/
const (
MetaDataPreComment = "MetaDataPreComment"
MetaDataPostComment = "MetaDataPostComment"
MetaDataGeneral = "MetaDataGeneral"
)
/*
Available lexer token types
*/
const (
TokenError LexTokenID = iota // Lexing error token with a message as val
TokenEOF // End-of-file token
TokenANY // Unspecified token (used when building an AST from a Go map structure)
TokenPRECOMMENT // Comment /* ... */
TokenPOSTCOMMENT // Comment # ...
// Value tokens
TokenSTRING // String constant
TokenNUMBER // Number constant
TokenIDENTIFIER // Idendifier
// Constructed tokens which are generated by the parser not the lexer
TokenSTATEMENTS // A code block
TokenFUNCCALL // A function call
TokenCOMPACCESS // Access to a composition structure
TokenLIST // List value
TokenMAP // MAP value
TokenPARAMS // Function parameters
TokenGUARD // Conditional statements
TOKENodeSYMBOLS // Used to separate symbols from other tokens in this list
// Condition operators
TokenGEQ
TokenLEQ
TokenNEQ
TokenEQ
TokenGT
TokenLT
// Grouping symbols
TokenLPAREN
TokenRPAREN
TokenLBRACK
TokenRBRACK
TokenLBRACE
TokenRBRACE
// Separators
TokenDOT
TokenCOMMA
TokenSEMICOLON
// Grouping
TokenCOLON
TokenEQUAL
// Arithmetic operators
TokenPLUS
TokenMINUS
TokenTIMES
TokenDIV
TokenDIVINT
TokenMODINT
// Assignment statement
TokenASSIGN
TokenLET
TOKENodeKEYWORDS // Used to separate keywords from other tokens in this list
// Import statement
TokenIMPORT
TokenAS
// Sink definition
TokenSINK
TokenKINDMATCH
TokenSCOPEMATCH
TokenSTATEMATCH
TokenPRIORITY
TokenSUPPRESSES
// Function definition
TokenFUNC
TokenRETURN
// Boolean operators
TokenAND
TokenOR
TokenNOT
// Condition operators
TokenLIKE
TokenIN
TokenHASPREFIX
TokenHASSUFFIX
TokenNOTIN
// Constant terminals
TokenFALSE
TokenTRUE
TokenNULL
// Conditional statements
TokenIF
TokenELIF
TokenELSE
// Loop statements
TokenFOR
TokenBREAK
TokenCONTINUE
// Try block
TokenTRY
TokenEXCEPT
TokenOTHERWISE
TokenFINALLY
// Mutex block
TokenMUTEX
TokenENDLIST
)
/*
IsValidTokenID check if a given token ID is valid.
*/
func IsValidTokenID(value int) bool {
return value < int(TokenENDLIST)
}
/*
Available parser AST node types
*/
const (
NodeEOF = "EOF"
NodeSTRING = "string" // String constant
NodeNUMBER = "number" // Number constant
NodeIDENTIFIER = "identifier" // Idendifier
// Constructed tokens
NodeSTATEMENTS = "statements" // List of statements
NodeFUNCCALL = "funccall" // Function call
NodeCOMPACCESS = "compaccess" // Composition structure access
NodeLIST = "list" // List value
NodeMAP = "map" // Map value
NodePARAMS = "params" // Function parameters
NodeGUARD = "guard" // Guard expressions for conditional statements
// Condition operators
NodeGEQ = ">="
NodeLEQ = "<="
NodeNEQ = "!="
NodeEQ = "=="
NodeGT = ">"
NodeLT = "<"
// Separators
NodeKVP = "kvp" // Key-value pair
NodePRESET = "preset" // Preset value
// Arithmetic operators
NodePLUS = "plus"
NodeMINUS = "minus"
NodeTIMES = "times"
NodeDIV = "div"
NodeMODINT = "modint"
NodeDIVINT = "divint"
// Assignment statement
NodeASSIGN = ":="
NodeLET = "let"
// Import statement
NodeIMPORT = "import"
// Sink definition
NodeSINK = "sink"
NodeKINDMATCH = "kindmatch"
NodeSCOPEMATCH = "scopematch"
NodeSTATEMATCH = "statematch"
NodePRIORITY = "priority"
NodeSUPPRESSES = "suppresses"
// Function definition
NodeFUNC = "function"
NodeRETURN = "return"
// Boolean operators
NodeAND = "and"
NodeOR = "or"
NodeNOT = "not"
// Condition operators
NodeLIKE = "like"
NodeIN = "in"
NodeHASPREFIX = "hasprefix"
NodeHASSUFFIX = "hassuffix"
NodeNOTIN = "notin"
// Constant terminals
NodeTRUE = "true"
NodeFALSE = "false"
NodeNULL = "null"
// Conditional statements
NodeIF = "if"
// Loop statements
NodeLOOP = "loop"
NodeBREAK = "break"
NodeCONTINUE = "continue"
// Try block
NodeTRY = "try"
NodeEXCEPT = "except"
NodeAS = "as"
NodeOTHERWISE = "otherwise"
NodeFINALLY = "finally"
// Mutex block
NodeMUTEX = "mutex"
) | parser/const.go | 0.706292 | 0.478163 | const.go | starcoder |
package pgtypes
import "github.com/apaxa-go/helper/mathh"
// SetInt sets z to x and returns z.
func (z *Numeric) SetInt(x int) *Numeric {
if x == 0 {
return z.SetZero()
}
if x < 0 {
z.sign = numericNegative
} else {
z.sign = numericPositive
}
z.weight = -1
z.digits = make([]int16, 0, 1) // as x!=0 there is at least 1 1000-base digit
for x != 0 {
d := mathh.AbsInt16(int16(x % numericBase))
x /= numericBase
if d != 0 || len(z.digits) > 0 { // avoid tailing zero
z.digits = append([]int16{d}, z.digits...)
}
z.weight++
}
return z
}
// SetUint sets z to x and returns z.
func (z *Numeric) SetUint(x uint) *Numeric {
if x == 0 {
return z.SetZero()
}
z.sign = numericPositive
z.weight = -1
z.digits = make([]int16, 0, 1) // as x!=0 there is at least 1 1000-base digit
for x != 0 {
d := int16(x % numericBase)
x /= numericBase
if d != 0 || len(z.digits) > 0 { // avoid tailing zero
z.digits = append([]int16{d}, z.digits...)
}
z.weight++
}
return z
}
// Uint returns the uint representation of x.
// If x is NaN, the result is 0.
// If x cannot be represented in an uint, the result is undefined.
func (x *Numeric) Uint() uint {
const maxWeight = mathh.UintBytes / 2 // Interesting, this should work at least for 1-8 bytes [unsigned] integers
if x.sign != numericPositive || len(x.digits) == 0 {
return 0
}
if x.weight > maxWeight {
return mathh.MaxUint
}
to := mathh.Min2Int(int(x.weight), len(x.digits)-1)
var r uint
for i := 0; i <= to; i++ {
r = r*numericBase + uint(x.digits[i])
}
for i := to + 1; i <= int(x.weight); i++ {
r *= numericBase
}
return r
}
// Int returns the int representation of x.
// If x is NaN, the result is 0.
// If x cannot be represented in an int, the result is undefined.
func (x *Numeric) Int() int {
const maxWeight = mathh.IntBytes / 2 // Interesting, this should work at least for 1-8 bytes [unsigned] integers
if x.sign == numericNaN || len(x.digits) == 0 {
return 0
}
var sign int
if x.sign == numericPositive {
if x.weight > maxWeight {
return mathh.MaxInt
}
sign = 1
} else {
if x.weight > maxWeight {
return mathh.MinInt
}
sign = -1
}
to := mathh.Min2Int(int(x.weight), len(x.digits)-1)
var r int
for i := 0; i <= to; i++ {
r = r*numericBase + sign*int(x.digits[i])
}
for i := to + 1; i <= int(x.weight); i++ {
r *= numericBase
}
return r
}
// SetInt16 sets z to x and returns z.
func (z *Numeric) SetInt16(x int16) *Numeric {
if x == 0 {
return z.SetZero()
}
if x < 0 {
z.sign = numericNegative
} else {
z.sign = numericPositive
}
z.weight = -1
z.digits = make([]int16, 0, 1) // as x!=0 there is at least 1 1000-base digit
for x != 0 {
d := mathh.AbsInt16(int16(x % numericBase))
x /= numericBase
if d != 0 || len(z.digits) > 0 { // avoid tailing zero
z.digits = append([]int16{d}, z.digits...)
}
z.weight++
}
return z
}
// SetUint16 sets z to x and returns z.
func (z *Numeric) SetUint16(x uint16) *Numeric {
if x == 0 {
return z.SetZero()
}
z.sign = numericPositive
z.weight = -1
z.digits = make([]int16, 0, 1) // as x!=0 there is at least 1 1000-base digit
for x != 0 {
d := int16(x % numericBase)
x /= numericBase
if d != 0 || len(z.digits) > 0 { // avoid tailing zero
z.digits = append([]int16{d}, z.digits...)
}
z.weight++
}
return z
}
// Uint16 returns the uint16 representation of x.
// If x is NaN, the result is 0.
// If x cannot be represented in an uint16, the result is undefined.
func (x *Numeric) Uint16() uint16 {
const maxWeight = mathh.Uint16Bytes / 2 // Interesting, this should work at least for 1-8 bytes [unsigned] integers
if x.sign != numericPositive || len(x.digits) == 0 {
return 0
}
if x.weight > maxWeight {
return mathh.MaxUint16
}
to := mathh.Min2Int(int(x.weight), len(x.digits)-1)
var r uint16
for i := 0; i <= to; i++ {
r = r*numericBase + uint16(x.digits[i])
}
for i := to + 1; i <= int(x.weight); i++ {
r *= numericBase
}
return r
}
// Int16 returns the int16 representation of x.
// If x is NaN, the result is 0.
// If x cannot be represented in an int16, the result is undefined.
func (x *Numeric) Int16() int16 {
const maxWeight = mathh.Int16Bytes / 2 // Interesting, this should work at least for 1-8 bytes [unsigned] integers
if x.sign == numericNaN || len(x.digits) == 0 {
return 0
}
var sign int16
if x.sign == numericPositive {
if x.weight > maxWeight {
return mathh.MaxInt16
}
sign = 1
} else {
if x.weight > maxWeight {
return mathh.MinInt16
}
sign = -1
}
to := mathh.Min2Int(int(x.weight), len(x.digits)-1)
var r int16
for i := 0; i <= to; i++ {
r = r*numericBase + sign*int16(x.digits[i])
}
for i := to + 1; i <= int(x.weight); i++ {
r *= numericBase
}
return r
}
// SetInt32 sets z to x and returns z.
func (z *Numeric) SetInt32(x int32) *Numeric {
if x == 0 {
return z.SetZero()
}
if x < 0 {
z.sign = numericNegative
} else {
z.sign = numericPositive
}
z.weight = -1
z.digits = make([]int16, 0, 1) // as x!=0 there is at least 1 1000-base digit
for x != 0 {
d := mathh.AbsInt16(int16(x % numericBase))
x /= numericBase
if d != 0 || len(z.digits) > 0 { // avoid tailing zero
z.digits = append([]int16{d}, z.digits...)
}
z.weight++
}
return z
}
// SetUint32 sets z to x and returns z.
func (z *Numeric) SetUint32(x uint32) *Numeric {
if x == 0 {
return z.SetZero()
}
z.sign = numericPositive
z.weight = -1
z.digits = make([]int16, 0, 1) // as x!=0 there is at least 1 1000-base digit
for x != 0 {
d := int16(x % numericBase)
x /= numericBase
if d != 0 || len(z.digits) > 0 { // avoid tailing zero
z.digits = append([]int16{d}, z.digits...)
}
z.weight++
}
return z
}
// Uint32 returns the uint32 representation of x.
// If x is NaN, the result is 0.
// If x cannot be represented in an uint32, the result is undefined.
func (x *Numeric) Uint32() uint32 {
const maxWeight = mathh.Uint32Bytes / 2 // Interesting, this should work at least for 1-8 bytes [unsigned] integers
if x.sign != numericPositive || len(x.digits) == 0 {
return 0
}
if x.weight > maxWeight {
return mathh.MaxUint32
}
to := mathh.Min2Int(int(x.weight), len(x.digits)-1)
var r uint32
for i := 0; i <= to; i++ {
r = r*numericBase + uint32(x.digits[i])
}
for i := to + 1; i <= int(x.weight); i++ {
r *= numericBase
}
return r
}
// Int32 returns the int32 representation of x.
// If x is NaN, the result is 0.
// If x cannot be represented in an int32, the result is undefined.
func (x *Numeric) Int32() int32 {
const maxWeight = mathh.Int32Bytes / 2 // Interesting, this should work at least for 1-8 bytes [unsigned] integers
if x.sign == numericNaN || len(x.digits) == 0 {
return 0
}
var sign int32
if x.sign == numericPositive {
if x.weight > maxWeight {
return mathh.MaxInt32
}
sign = 1
} else {
if x.weight > maxWeight {
return mathh.MinInt32
}
sign = -1
}
to := mathh.Min2Int(int(x.weight), len(x.digits)-1)
var r int32
for i := 0; i <= to; i++ {
r = r*numericBase + sign*int32(x.digits[i])
}
for i := to + 1; i <= int(x.weight); i++ {
r *= numericBase
}
return r
}
// NewInt allocates and returns a new Numeric set to x.
func NewInt(x int) *Numeric {
var r Numeric
return r.SetInt(x)
}
// NewInt8 allocates and returns a new Numeric set to x.
func NewInt8(x int8) *Numeric {
var r Numeric
return r.SetInt8(x)
}
// NewInt16 allocates and returns a new Numeric set to x.
func NewInt16(x int16) *Numeric {
var r Numeric
return r.SetInt16(x)
}
// NewInt32 allocates and returns a new Numeric set to x.
func NewInt32(x int32) *Numeric {
var r Numeric
return r.SetInt32(x)
}
// NewUint allocates and returns a new Numeric set to x.
func NewUint(x uint) *Numeric {
var r Numeric
return r.SetUint(x)
}
// NewUint8 allocates and returns a new Numeric set to x.
func NewUint8(x uint8) *Numeric {
var r Numeric
return r.SetUint8(x)
}
// NewUint16 allocates and returns a new Numeric set to x.
func NewUint16(x uint16) *Numeric {
var r Numeric
return r.SetUint16(x)
}
// NewUint32 allocates and returns a new Numeric set to x.
func NewUint32(x uint32) *Numeric {
var r Numeric
return r.SetUint32(x)
}
// NewUint64 allocates and returns a new Numeric set to x.
func NewUint64(x uint64) *Numeric {
var r Numeric
return r.SetUint64(x)
} | numeric-ints-gen.go | 0.639736 | 0.567218 | numeric-ints-gen.go | starcoder |
package common
/*
#include <stdlib.h>
#include <stdbool.h>
#include "openvision/common/common.h"
*/
import "C"
import (
"unsafe"
)
// Rectangle represents a Rectangle
type Rectangle struct {
X float64
Y float64
Width float64
Height float64
}
// Rect returns a Retancle
func Rect(x, y, w, h float64) Rectangle {
return Rectangle{
X: x,
Y: y,
Width: w,
Height: h,
}
}
// MaxX returns right x
func (r Rectangle) MaxX() float64 {
return r.X + r.Width
}
// MaxY returns bottom y
func (r Rectangle) MaxY() float64 {
return r.Y + r.Height
}
// CRect returns C.Rect
func (r Rectangle) CRect(w float64, h float64) *C.Rect {
v := (*C.Rect)(C.malloc(C.sizeof_Rect))
v.x = C.int(r.X * w)
v.y = C.int(r.Y * h)
v.width = C.int(r.Width * w)
v.height = C.int(r.Height * h)
return v
}
// GoRect convert C.Rect to go type
func GoRect(c *C.Rect, w float64, h float64) Rectangle {
return Rect(
float64(c.x)/w,
float64(c.y)/h,
float64(c.width)/w,
float64(c.height)/h,
)
}
var ZR = Rectangle{}
var FullRect = Rect(0, 0, 1, 1)
// Point represents a Point
type Point struct {
X float64
Y float64
}
// Pt returns a New Point
func Pt(x, y float64) Point {
return Point{x, y}
}
var ZP = Point{}
// GoPoint2f conver C.Point2f to Point
func GoPoint2f(c *C.Point2f, w float64, h float64) Point {
return Pt(
float64(c.x)/w,
float64(c.y)/h,
)
}
// NewCPoint2fVector retruns C.Point2fVector pointer
func NewCPoint2fVector() *C.Point2fVector {
return (*C.Point2fVector)(C.malloc(C.sizeof_Point2f))
}
// GoPoint2fVector convert C.Point2fVector to []Point
func GoPoint2fVector(cVector *C.Point2fVector, w float64, h float64) []Point {
if cVector == nil {
return nil
}
l := int(cVector.length)
ret := make([]Point, 0, l)
ptr := unsafe.Pointer(cVector.points)
for i := 0; i < l; i++ {
cPoint2f := (*C.Point2f)(unsafe.Pointer(uintptr(ptr) + uintptr(C.sizeof_Point2f*C.int(i))))
ret = append(ret, GoPoint2f(cPoint2f, w, h))
}
return ret
}
// FreeCPoint2fVector release C.Point2fVector memory
func FreeCPoint2fVector(c *C.Point2fVector) {
C.FreePoint2fVector(c)
C.free(unsafe.Pointer(c))
}
// Point3d represents a 3dPoint
type Point3d struct {
X float64
Y float64
Z float64
}
// Pt3d returns a New Point3d
func Pt3d(x, y, z float64) Point3d {
return Point3d{x, y, z}
}
var ZP3d = Point3d{}
// GoPoint3d conver C.Point3d to Point3d
func GoPoint3d(c *C.Point3d) Point3d {
return Pt3d(
float64(c.x),
float64(c.y),
float64(c.z),
)
}
// NewCPoint3dVector retruns C.Point3dVector pointer
func NewCPoint3dVector() *C.Point3dVector {
return (*C.Point3dVector)(C.malloc(C.sizeof_Point3d))
}
// GoPoint3dVector convert C.Point3dVector to []Point3d
func GoPoint3dVector(cVector *C.Point3dVector) []Point3d {
if cVector == nil {
return nil
}
l := int(cVector.length)
ret := make([]Point3d, 0, l)
ptr := unsafe.Pointer(cVector.points)
for i := 0; i < l; i++ {
cPoint3d := (*C.Point3d)(unsafe.Pointer(uintptr(ptr) + uintptr(C.sizeof_Point3d*C.int(i))))
ret = append(ret, GoPoint3d(cPoint3d))
}
return ret
}
// FreeCPoint3dVector release C.Point3dVector memory
func FreeCPoint3dVector(c *C.Point3dVector) {
C.FreePoint3dVector(c)
C.free(unsafe.Pointer(c))
} | go/common/geometry.go | 0.699357 | 0.482124 | geometry.go | starcoder |
package validator
import "fmt"
// DigitsBetweenUint64 returns true if value lies between left and right border
func DigitsBetweenUint64(value, left, right uint64) bool {
if left > right {
left, right = right, left
}
return value >= left && value <= right
}
// compareUint64 determine if a comparison passes between the given values.
func compareUint64(first uint64, second uint64, operator string) bool {
switch operator {
case "<":
return first < second
case ">":
return first > second
case "<=":
return first <= second
case ">=":
return first >= second
case "==":
return first == second
default:
panic(fmt.Sprintf("validator: compareUint64 unsupport operator %s", operator))
}
}
// DistinctUint is the validation function for validating an attribute is unique among other values.
func DistinctUint(v []uint) bool {
return inArrayUint(v, v)
}
// DistinctUint8 is the validation function for validating an attribute is unique among other values.
func DistinctUint8(v []uint8) bool {
return inArrayUint8(v, v)
}
// DistinctUint16 is the validation function for validating an attribute is unique among other values.
func DistinctUint16(v []uint16) bool {
return inArrayUint16(v, v)
}
// DistinctUint32 is the validation function for validating an attribute is unique among other values.
func DistinctUint32(v []uint32) bool {
return inArrayUint32(v, v)
}
// DistinctUint64 is the validation function for validating an attribute is unique among other values.
func DistinctUint64(v []uint64) bool {
return inArrayUint64(v, v)
}
func inArrayUint(needle []uint, haystack []uint) bool {
for _, n := range needle {
for _, s := range haystack {
if n == s {
return true
}
}
}
return false
}
func inArrayUint8(needle []uint8, haystack []uint8) bool {
for _, n := range needle {
for _, s := range haystack {
if n == s {
return true
}
}
}
return false
}
func inArrayUint16(needle []uint16, haystack []uint16) bool {
for _, n := range needle {
for _, s := range haystack {
if n == s {
return true
}
}
}
return false
}
func inArrayUint32(needle []uint32, haystack []uint32) bool {
for _, n := range needle {
for _, s := range haystack {
if n == s {
return true
}
}
}
return false
}
func inArrayUint64(needle []uint64, haystack []uint64) bool {
for _, n := range needle {
for _, s := range haystack {
if n == s {
return true
}
}
}
return false
} | validator_unit.go | 0.772015 | 0.55646 | validator_unit.go | starcoder |
package game
import (
"fmt"
"math"
)
var potentialValueRanges = [][]int {
{100, 200, 300, 400, 500},
{200, 400, 600, 800, 1000},
{400, 800, 1200, 1600, 2000},
}
// FixValues corrects duplicate values, fixes values that sit outside the
// normal procession, and changes the values so that they match the numbers
// used in normal play.
func FixValues(cat *Category) error {
if err := inferValues(cat); err != nil {
return err
}
return targetRoundValues(cat)
}
// inferValues computes the value of a question to match standard values, in the
// case that there questions with abnormal values. Modifies the questions in
// place. Errors if it is unable to determine values for the category.
func inferValues(cat *Category) error {
if len(cat.Questions) != 5 {
return fmt.Errorf("can only infer values when a category has exactly 5 questions, got %v", len(cat.Questions))
}
if err := deduplicate(cat); err != nil {
return err
}
return normalize(cat)
}
// estimateValueRange attempts to determine the series of values this Category
// has.
func estimateValueRange(cat *Category) ([]int, error) {
buckets := make(map[int][]*Question)
for _, q := range cat.Questions{
buckets[q.Value] = append(buckets[q.Value], q)
}
for _, r := range potentialValueRanges {
matches := 0
for _, q := range cat.Questions {
for _, v := range r {
if q.Value == v {
matches = matches + 1
}
}
}
if matches >= 4 {
return r, nil
}
}
return nil, fmt.Errorf("could not infer value range for category, too may values that are not standard")
}
// deduplicate attempts to correct categories that have questions with duplicate
// values. Modifies the questions in place.
func deduplicate(cat *Category) error {
buckets := make(map[int][]*Question)
for _, q := range cat.Questions{
buckets[q.Value] = append(buckets[q.Value], q)
}
var dupe []*Question
for _, questions := range buckets {
if len(questions) > 2 {
return fmt.Errorf("categories values cannot be inferred, to many questions outlier")
}
if len(questions) == 2 && dupe != nil {
return fmt.Errorf("category has too many duplicates, cannot infer values")
}
if len(questions) == 2 {
dupe = questions
}
}
if dupe == nil {
return nil
}
expectedValues, err := estimateValueRange(cat)
if err != nil {
return err
}
missingValue := 0
for _, v := range expectedValues {
if _, ok := buckets[v]; !ok {
missingValue = v
}
}
dupe[1].Value = missingValue
return nil
}
// normalize attempts to correct categories that have questions that aren't in
// line with a standard range.
func normalize(cat *Category) error {
buckets := make(map[int][]*Question)
for _, q := range cat.Questions{
buckets[q.Value] = append(buckets[q.Value], q)
}
expectedValues, err := estimateValueRange(cat)
if err != nil {
return err
}
missingValue := 0
for _, v := range expectedValues {
if _, ok := buckets[v]; !ok {
missingValue = v
}
}
for v, b := range buckets {
found := false
for _, val := range expectedValues {
if v == val {
found = true
}
}
if found {
continue
}
b[0].Value = missingValue
}
return nil
}
func doubleValues(cat *Category) {
for _, q := range cat.Questions {
q.Value = q.Value * 2
}
}
// targetRoundValues attempts to adjust the values of a category to match the
// values for the round its in.
func targetRoundValues(cat *Category) error {
if len(cat.Questions) != 5 {
return fmt.Errorf("can only target values when a category has exactly 5 questions, got %v", len(cat.Questions))
}
round := cat.Questions[0].Round
// Since the questions have already been fixed, we can take the lowest value
// question and use it as a basis.
min := math.MaxInt32
for _, q := range cat.Questions {
if q.Value < min {
min = q.Value
}
}
// If they're already correct, we're done.
if round == DAIICHI && min == 200 || round == DAINI && min == 400 {
return nil
}
if round == DAIICHI && min == 100 || round == DAINI && min == 200 {
doubleValues(cat)
return nil
}
return fmt.Errorf("unable to determine correct range for values in category")
} | server/src/github.com/baconstrip/kiken/game/values.go | 0.727395 | 0.503418 | values.go | starcoder |
package main
import (
"math"
)
// Circle Maps a circle object
type Circle ObjectElement
func generateCircleFilledFromObject(object *Object) (Circle) {
return generateCircle(object.Distance, object.Radius, object.Radiate)
}
func generateCircleFromObject(object *Object) (Circle) {
return generateCircle(object.Radius, 0.0, object.Radiate)
}
func generateCircle(radius float32, thickness float32, radiate bool) (Circle) {
var (
circle Circle
i int
j int
k int
l int
accumulatorMainSize int32
accumulatorIndicesSize int32
normalDirection float32
radiusInsideN float32
radiusOutsideN float32
nbVertices int32
angle float64
angleMax int32
)
angleMax = 360
if thickness > 0 {
accumulatorMainSize = 2
accumulatorIndicesSize = 6
} else {
accumulatorMainSize = 1
accumulatorIndicesSize = 2
}
circle.Vertices = make([]float32, 3 * (angleMax + 1) * accumulatorMainSize)
circle.VerticeNormals = make([]float32, 3 * (angleMax + 1) * accumulatorMainSize)
circle.Indices = make([]int32, (angleMax + 1) * accumulatorIndicesSize)
circle.TextureCoords = make([]float32, 2 * (angleMax + 1) * accumulatorMainSize)
i = 0
j = 0
k = 0
l = 0
nbVertices = 1
radiusInsideN = normalizeObjectSize(radius)
radiusOutsideN = normalizeObjectSize(radius + thickness)
// Normal is -1 if sun, which is the light source, to avoid any self-shadow effect
if radiate == true {
normalDirection = -1.0
} else {
normalDirection = 1.0
}
for angle = 0.0; angle <= float64(angleMax); angle++ {
// Generate inner circle object
generateCircleObject(&circle, radiusInsideN, thickness, angle, angleMax, normalDirection, nbVertices, 0, &i, &j, &k, &l)
if thickness > 0.0 {
// Generate outer circle object? (if not last)
generateCircleObject(&circle, radiusOutsideN, thickness, angle, angleMax, normalDirection, nbVertices, 1, &i, &j, &k, &l)
nbVertices++
}
nbVertices++
}
return circle
}
func generateCircleObject(circle *Circle, radiusN float32, thickness float32, angle float64, angleMax int32, normalDirection float32, nbVertices int32, passIndex int32, i *int, j *int, k *int, l *int) {
var (
vertexPositionX float32
vertexPositionY float32
vertexPositionZ float32
)
// Generate inside circle vertices
vertexPositionX = float32(math.Cos(ConfigMathDegreeToRadian * angle))
vertexPositionY = 0.0
vertexPositionZ = float32(math.Sin(ConfigMathDegreeToRadian * angle))
// Bind inside circle vertices
circle.Vertices[*i] = radiusN * vertexPositionX
circle.Vertices[*i + 1] = radiusN * vertexPositionY
circle.Vertices[*i + 2] = radiusN * vertexPositionZ
*i += 3
// Bind circle vertice normals
circle.VerticeNormals[*j] = normalDirection * vertexPositionX
circle.VerticeNormals[*j + 1] = normalDirection * vertexPositionY
circle.VerticeNormals[*j + 2] = normalDirection * vertexPositionZ
*j += 3
// Bind circle indices
if thickness > 0.0 {
circle.Indices[*k] = (nbVertices % (angleMax * 2)) + 1
circle.Indices[*k + 1] = ((nbVertices + 1 + passIndex) % (angleMax * 2)) + 1
circle.Indices[*k + 2] = ((nbVertices + 3) % (angleMax * 2)) + 1
*k += 3
} else {
circle.Indices[*k] = ((nbVertices) % angleMax) + 1
circle.Indices[*k + 1] = ((nbVertices + 1) % angleMax) + 1
*k += 2
}
// Bind circle texture coordinates
circle.TextureCoords[*l] = float32(passIndex)
circle.TextureCoords[*l + 1] = 0.0
*l += 2
} | circle.go | 0.783036 | 0.461684 | circle.go | starcoder |
package twilight
import (
"math"
)
func daysSince2000(y, m, d int) float64 {
return float64(367*(y) - ((7 * ((y) + (((m) + 9) / 12))) / 4) + ((275 * (m)) / 9) + (d) - 730530)
}
const (
inv360 = float64(1.0 / 360.0)
radToDeg = 180.0 / math.Pi
degToRad = math.Pi / 180.0
)
// revolution will reduce the angle to within 0-360 degrees
func revolution(x float64) float64 {
return x - 360.0*math.Floor(x*inv360)
}
// rev180 will reduce the angle to within 180-180 degrees
func rev180(x float64) float64 {
return x - 360.0*math.Floor(x*inv360+0.5)
}
func sind(x float64) float64 {
return math.Sin(x * degToRad)
}
func cosd(x float64) float64 {
return math.Cos(x * degToRad)
}
func tand(x float64) float64 {
return math.Tan(x * degToRad)
}
func atand(x float64) float64 {
return radToDeg * math.Atan(x)
}
func asindh(x float64) float64 {
return radToDeg * math.Asin(x)
}
func acosd(x float64) float64 {
return radToDeg * math.Acos(x)
}
func atan2d(y, x float64) float64 {
return radToDeg * math.Atan2(y, x)
}
func sunpos(d float64) (lon, r float64) {
M := revolution(356.0470 + 0.9856002585*d)
w := 282.9404 + 4.70935E-5*d
e := 0.016709 - 1.151E-9*d
E := M + e*radToDeg*sind(M)*(1.0+e*cosd(M))
x := cosd(E) - e
y := math.Sqrt(1.0-e*e) * sind(E)
r = math.Sqrt(x*x + y*y)
v := atan2d(y, x)
lon = v + w
for lon >= 360.0 {
lon -= 360.0
}
return lon, r
}
func gmst0(d float64) float64 {
return revolution((180.0 + 356.0470 + 282.9404) + (0.9856002585+4.70935E-5)*d)
}
func sunRADec(d float64) (ra, dec, r float64) {
var lon float64
lon, r = sunpos(d)
x := r * cosd(lon)
y := r * sind(lon)
oblEcl := 23.4393 - 3.563E-7*d
z := y * sind(oblEcl)
y = y * cosd(oblEcl)
ra = atan2d(y, x)
dec = atan2d(z, math.Sqrt(x*x+y*y))
return ra, dec, r
}
func sunRiseSet(year, month, day int, lon, lat float64, sunAlt float64, upperLimb bool) (float64, float64, SunriseStatus) {
d := daysSince2000(year, month, day)
sidTime := revolution(gmst0(d) + 180.0 + lon)
sRA, sDec, sR := sunRADec(d)
tSouth := 12.0 - rev180(sidTime-sRA)/15.0
if upperLimb {
sRadius := 0.2666 / sR
sunAlt -= sRadius
}
cost := (sind(sunAlt) - sind(lat)*sind(sDec)) / (cosd(lat) * cosd(sDec))
var s SunriseStatus
var t float64
switch {
case cost >= 1.0:
t = 0.0
s = SunriseStatusBelowHorizon
case cost <= -1.0:
t = 12.0
s = SunriseStatusAboveHorizon
default:
t = acosd(cost) / 15.0
s = SunriseStatusOK
}
return tSouth - t, tSouth + t, s
}
func dayLen(year, month, day int, lon, lat float64, sunAlt float64, upperLimb bool) float64 {
d := daysSince2000(year, month, day) + 0.5 - lon/360.0
oblEcl := 23.4393 - 3.563E-7*d
sLon, sR := sunpos(d)
sinSDec := sind(oblEcl) * sind(sLon)
cosSDec := math.Sqrt(1.0 - sinSDec*sinSDec)
if upperLimb {
sRadius := 0.2666 / sR
sunAlt -= sRadius
}
cost := (sind(sunAlt) - sind(lat)*sinSDec) / (cosd(lat) * cosSDec)
var t float64
switch {
case cost >= 1.0:
t = 0.0
case cost <= -1.0:
t = 24.0
default:
t = (2.0 / 15.0) * acosd(cost)
}
return t
} | helper.go | 0.816699 | 0.557604 | helper.go | starcoder |
package xpytest
import (
"context"
"fmt"
"math"
"path/filepath"
"regexp"
"runtime"
"sort"
"strings"
"sync"
"time"
"github.com/bmatcuk/doublestar"
"github.com/chainer/xpytest/pkg/pytest"
"github.com/chainer/xpytest/pkg/reporter"
"github.com/chainer/xpytest/pkg/resourcebuckets"
xpytest_proto "github.com/chainer/xpytest/proto"
)
const resourceResolution = 1000
// Xpytest is a controller for pytest queries.
type Xpytest struct {
PytestBase *pytest.Pytest
Tests []*xpytest_proto.TestQuery
TestResults []*xpytest_proto.TestResult
Status xpytest_proto.TestResult_Status
}
// NewXpytest creates a new Xpytest.
func NewXpytest(base *pytest.Pytest) *Xpytest {
return &Xpytest{PytestBase: base}
}
// GetTests returns test queries.
func (x *Xpytest) GetTests() []*xpytest_proto.TestQuery {
if x.Tests == nil {
return []*xpytest_proto.TestQuery{}
}
return x.Tests
}
// AddTestsWithFilePattern adds test files based on the given file pattern.
func (x *Xpytest) AddTestsWithFilePattern(pattern string) error {
files, err := doublestar.Glob(pattern)
if err != nil {
return fmt.Errorf(
"failed to find files with pattern: %s: %s", pattern, err)
}
for _, f := range files {
if regexp.MustCompile(`^test_.*\.py$`).MatchString(filepath.Base(f)) {
x.Tests = append(x.GetTests(), &xpytest_proto.TestQuery{File: f})
}
}
return nil
}
// ApplyHint applies hint information to test cases.
// CAVEAT: This computation order is O(n^2). This can be improved by sorting by
// suffixes.
func (x *Xpytest) ApplyHint(h *xpytest_proto.HintFile) error {
rules := append(h.GetRules(), h.GetSlowTests()...)
for i := range rules {
priority := i + 1
rule := rules[len(rules)-i-1]
for _, tq := range x.GetTests() {
if tq.GetFile() == rule.GetName() ||
strings.HasSuffix(tq.GetFile(), string(filepath.Separator)+
rule.GetName()) {
tq.Priority = int32(priority)
if rule.GetDeadline() != 0 {
tq.Deadline = rule.GetDeadline()
} else {
tq.Deadline = 600.0
}
if rule.GetXdist() != 0 {
tq.Xdist = rule.GetXdist()
}
if rule.GetRetry() > 0 {
tq.Retry = rule.GetRetry()
}
if rule.GetResource() > 0 {
tq.Resource = rule.GetResource()
}
}
}
}
return nil
}
// Execute runs tests.
func (x *Xpytest) Execute(
ctx context.Context, bucket int, thread int,
reporter reporter.Reporter,
) error {
tests := append([]*xpytest_proto.TestQuery{}, x.Tests...)
sort.SliceStable(tests, func(i, j int) bool {
a, b := tests[i], tests[j]
if a.Priority == b.Priority {
return a.File < b.File
}
return a.Priority > b.Priority
})
if thread == 0 {
thread = (runtime.NumCPU() + bucket - 1) / bucket
}
rb := resourcebuckets.NewResourceBuckets(bucket, thread*resourceResolution)
resultChan := make(chan *pytest.Result, thread)
printer := sync.WaitGroup{}
printer.Add(1)
go func() {
defer printer.Done()
passedTests := []*pytest.Result{}
flakyTests := []*pytest.Result{}
failedTests := []*pytest.Result{}
for {
r, ok := <-resultChan
if !ok {
break
}
fmt.Println(r.Output())
if r.Status == xpytest_proto.TestResult_SUCCESS {
passedTests = append(passedTests, r)
} else if r.Status == xpytest_proto.TestResult_FLAKY {
flakyTests = append(flakyTests, r)
} else {
failedTests = append(failedTests, r)
}
}
x.Status = xpytest_proto.TestResult_SUCCESS
if len(flakyTests) > 0 {
fmt.Printf("\n%s\n", horizon("FLAKY TESTS"))
for _, t := range flakyTests {
fmt.Printf("%s\n", t.Summary())
if reporter != nil {
reporter.Log(ctx, t.Summary())
}
}
x.Status = xpytest_proto.TestResult_FLAKY
}
if len(failedTests) > 0 {
fmt.Printf("\n%s\n", horizon("FAILED TESTS"))
for _, t := range failedTests {
fmt.Printf("%s\n", t.Summary())
}
x.Status = xpytest_proto.TestResult_FAILED
}
fmt.Printf("\n%s\n", horizon("TEST SUMMARY"))
fmt.Printf("%d failed, %d flaky, %d passed\n",
len(failedTests), len(flakyTests), len(passedTests))
}()
wg := sync.WaitGroup{}
for _, t := range tests {
t := t
usage := rb.Acquire(func() int {
req := float64(resourceResolution)
if t.Xdist > 0 {
req *= float64(t.Xdist)
}
if t.Resource > 0 {
req *= float64(t.Resource)
}
return int(math.Ceil(req))
}())
wg.Add(1)
go func() {
defer wg.Done()
defer rb.Release(usage)
pt := *x.PytestBase
pt.Files = []string{t.File}
pt.Xdist = int(t.Xdist)
if pt.Xdist > thread {
pt.Xdist = thread
}
if t.Retry != 0 {
pt.Retry = int(t.Retry)
}
pt.Env = []string{
fmt.Sprintf("CUDA_VISIBLE_DEVICES=%s", func() string {
s := []string{}
for i := 0; i < bucket; i++ {
s = append(s, fmt.Sprintf("%d", (i+usage.Index)%bucket))
}
return strings.Join(s, ",")
}()),
}
if t.Deadline != 0 {
pt.Deadline = time.Duration(t.Deadline*1e6) * time.Microsecond
}
r, err := pt.Execute(ctx)
if err != nil {
panic(fmt.Sprintf("failed execute pytest: %s: %s", t.File, err))
}
resultChan <- r
}()
}
wg.Wait()
close(resultChan)
printer.Wait()
return nil
}
func horizon(title string) string {
if title == "" {
return strings.Repeat("=", 70)
}
title = " " + strings.TrimSpace(title) + " "
s := strings.Repeat("=", (70-len(title))/2) + title
return s + strings.Repeat("=", 70-len(s))
} | pkg/xpytest/xpytest.go | 0.565299 | 0.469095 | xpytest.go | starcoder |
package sq
import "github.com/MaxSlyugrov/cldr"
var calendar = cldr.Calendar{
Formats: cldr.CalendarFormats{
Date: cldr.CalendarDateFormat{Full: "EEEE, d MMMM y", Long: "d MMMM y", Medium: "d MMM y", Short: "d.M.yy"},
Time: cldr.CalendarDateFormat{Full: "HH:mm:ss zzzz", Long: "HH:mm:ss z", Medium: "HH:mm:ss", Short: "HH:mm"},
DateTime: cldr.CalendarDateFormat{Full: "{1} 'në' {0}", Long: "{1} 'në' {0}", Medium: "{1}, {0}", Short: "{1}, {0}"},
},
FormatNames: cldr.CalendarFormatNames{
Months: cldr.CalendarMonthFormatNames{
Abbreviated: cldr.CalendarMonthFormatNameValue{Jan: "Jan", Feb: "Shk", Mar: "Mar", Apr: "Pri", May: "Maj", Jun: "Qer", Jul: "Kor", Aug: "Gsh", Sep: "Sht", Oct: "Tet", Nov: "Nën", Dec: "Dhj"},
Narrow: cldr.CalendarMonthFormatNameValue{Jan: "J", Feb: "S", Mar: "M", Apr: "P", May: "M", Jun: "Q", Jul: "K", Aug: "G", Sep: "S", Oct: "T", Nov: "N", Dec: "D"},
Short: cldr.CalendarMonthFormatNameValue{},
Wide: cldr.CalendarMonthFormatNameValue{Jan: "Janar", Feb: "Shkurt", Mar: "Mars", Apr: "Prill", May: "Maj", Jun: "Qershor", Jul: "Korrik", Aug: "Gusht", Sep: "Shtator", Oct: "Tetor", Nov: "Nëntor", Dec: "Dhjetor"},
},
Days: cldr.CalendarDayFormatNames{
Abbreviated: cldr.CalendarDayFormatNameValue{Sun: "Die", Mon: "Hën", Tue: "Mar", Wed: "Mër", Thu: "Enj", Fri: "Pre", Sat: "Sht"},
Narrow: cldr.CalendarDayFormatNameValue{Sun: "D", Mon: "H", Tue: "M", Wed: "M", Thu: "E", Fri: "P", Sat: "S"},
Short: cldr.CalendarDayFormatNameValue{Sun: "Die", Mon: "Hën", Tue: "Mar", Wed: "Mër", Thu: "Enj", Fri: "Pre", Sat: "Sht"},
Wide: cldr.CalendarDayFormatNameValue{Sun: "E diel", Mon: "E hënë", Tue: "E martë", Wed: "E mërkurë", Thu: "E enjte", Fri: "E premte", Sat: "E shtunë"},
},
Periods: cldr.CalendarPeriodFormatNames{
Abbreviated: cldr.CalendarPeriodFormatNameValue{},
Narrow: cldr.CalendarPeriodFormatNameValue{AM: "AM", PM: "PM"},
Short: cldr.CalendarPeriodFormatNameValue{},
Wide: cldr.CalendarPeriodFormatNameValue{AM: "paradite", PM: "pasdite"},
},
},
} | resources/locales/sq/calendar.go | 0.53777 | 0.435481 | calendar.go | starcoder |
package docs
import (
"strings"
"github.com/Jeffail/benthos/v3/lib/util/config"
"github.com/Jeffail/gabs/v2"
)
// FieldSpecCtx provides a field spec and rendered extras for documentation
// templates to use.
type FieldSpecCtx struct {
Spec FieldSpec
// FullName describes the full dot path name of the field relative to
// the root of the documented component.
FullName string
// ExamplesMarshalled is a list of examples marshalled into YAML format.
ExamplesMarshalled []string
// DefaultMarshalled is a marshalled string of the default value, if there is one.
DefaultMarshalled string
}
// FieldsTemplate returns a Go template for rendering markdown field
// documentation. The context should have a field `.Fields` of the type
// `[]FieldSpecCtx`.
func FieldsTemplate(lintableExamples bool) string {
exampleHint := "yml"
if lintableExamples {
exampleHint = "yaml"
}
return `{{define "field_docs" -}}
{{range $i, $field := .Fields -}}
### ` + "`{{$field.FullName}}`" + `
{{$field.Spec.Description}}
{{if $field.Spec.Interpolated -}}
This field supports [interpolation functions](/docs/configuration/interpolation#bloblang-queries).
{{end}}
Type: {{if eq $field.Spec.Kind "array"}}list of {{end}}{{if eq $field.Spec.Kind "map"}}map of {{end}}` + "`{{$field.Spec.Type}}`" + `
{{if gt (len $field.DefaultMarshalled) 0}}Default: ` + "`{{$field.DefaultMarshalled}}`" + `
{{end -}}
{{if gt (len $field.Spec.Version) 0}}Requires version {{$field.Spec.Version}} or newer
{{end -}}
{{if gt (len $field.Spec.AnnotatedOptions) 0}}
| Option | Summary |
|---|---|
{{range $j, $option := $field.Spec.AnnotatedOptions -}}` + "| `" + `{{index $option 0}}` + "` |" + ` {{index $option 1}} |
{{end}}
{{else if gt (len $field.Spec.Options) 0}}Options: {{range $j, $option := $field.Spec.Options -}}
{{if ne $j 0}}, {{end}}` + "`" + `{{$option}}` + "`" + `{{end}}.
{{end}}
{{if gt (len $field.Spec.Examples) 0 -}}
` + "```" + exampleHint + `
# Examples
{{range $j, $example := $field.ExamplesMarshalled -}}
{{if ne $j 0}}
{{end}}{{$example}}{{end -}}
` + "```" + `
{{end -}}
{{end -}}
{{end -}}`
}
// FlattenChildrenForDocs converts the children of a field into a flat list,
// where the names contain hints as to their position in a structured hierarchy.
// This makes it easier to list the fields in documentation.
func (f FieldSpec) FlattenChildrenForDocs() []FieldSpecCtx {
flattenedFields := []FieldSpecCtx{}
var walkFields func(path string, f FieldSpecs)
walkFields = func(path string, f FieldSpecs) {
for _, v := range f {
if v.IsDeprecated {
continue
}
newV := FieldSpecCtx{
Spec: v,
}
newV.FullName = newV.Spec.Name
if len(path) > 0 {
newV.FullName = path + newV.Spec.Name
}
if len(v.Examples) > 0 {
newV.ExamplesMarshalled = make([]string, len(v.Examples))
for i, e := range v.Examples {
exampleBytes, err := config.MarshalYAML(map[string]interface{}{
v.Name: e,
})
if err == nil {
newV.ExamplesMarshalled[i] = string(exampleBytes)
}
}
}
if v.Default != nil {
newV.DefaultMarshalled = gabs.Wrap(*v.Default).String()
}
newV.Spec.Description = strings.TrimSpace(v.Description)
if newV.Spec.Description == "" {
newV.Spec.Description = "Sorry! This field is missing documentation."
}
flattenedFields = append(flattenedFields, newV)
if len(v.Children) > 0 {
newPath := path + v.Name
switch newV.Spec.Kind {
case KindArray:
newPath += "[]"
case Kind2DArray:
newPath += "[][]"
case KindMap:
newPath += ".<name>"
}
walkFields(newPath+".", v.Children)
}
}
}
rootPath := ""
switch f.Kind {
case KindArray:
rootPath = "[]."
case KindMap:
rootPath = "<name>."
}
walkFields(rootPath, f.Children)
return flattenedFields
} | internal/docs/field_template.go | 0.714728 | 0.619989 | field_template.go | starcoder |
package messages
/*
This go file centralizes error log messages so we have them all in one place.
Although having the names of the consts as the error code (i.e CSPFK014E) and not as a descriptive name (i.e InvalidStoreType)
can reduce readability of the code that raises the error, we decided to do so for the following reasons:
1. Improves supportability – when we get this code in the log we can find it directly in the code without going
through the “info_messages.go” file first
2. Validates we don’t have error code duplications – If the code is only in the string then 2 errors can have the
same code (which is something that a developer can easily miss). However, If they are in the object name
then the compiler will not allow it.
*/
// Access Token
const CSPFK001E string = "CSPFK001E Failed to create access token object"
const CSPFK002E string = "CSPFK002E Failed to retrieve access token"
const CSPFK003E string = "CSPFK003E AccessToken failed to delete access token data. Reason: %s"
// Environment variables
const CSPFK004E string = "CSPFK004E Environment variable '%s' must be provided"
const CSPFK005E string = "CSPFK005E Provided incorrect value for environment variable %s"
const CSPFK007E string = "CSPFK007E Setting SECRETS_DESTINATION environment variable to 'k8s_secrets' must run as init container"
// Authenticator
const CSPFK008E string = "CSPFK008E Failed to instantiate authenticator configuration"
const CSPFK009E string = "CSPFK009E Failed to instantiate authenticator object"
const CSPFK010E string = "CSPFK010E Failed to authenticate"
const CSPFK011E string = "CSPFK011E Failed to parse authentication response"
// ProvideConjurSecrets
const CSPFK014E string = "CSPFK014E Failed to instantiate ProvideConjurSecrets function. Reason: %s"
const CSPFK015E string = "CSPFK015E Failed to instantiate secrets config"
const CSPFK016E string = "CSPFK016E Failed to provide Conjur secrets"
// Kubernetes
const CSPFK018E string = "CSPFK018E Failed to create Kubernetes client"
const CSPFK019E string = "CSPFK019E Failed to load in-cluster Kubernetes client config"
const CSPFK020E string = "CSPFK020E Failed to retrieve k8s secret"
const CSPFK021E string = "CSPFK021E Failed to retrieve k8s secrets"
const CSPFK022E string = "CSPFK022E Failed to patch k8s secret"
const CSPFK023E string = "CSPFK023E Failed to patch K8s secrets"
const CSPFK024E string = "CSPFK024E Failed to create stringDataEntry"
const CSPFK025E string = "CSPFK025E PathMap cannot be empty"
const CSPFK026E string = "CSPFK026E Data entry map cannot be empty"
const CSPFK027E string = "CSPFK027E Failed to update K8s secrets map with Conjur secrets"
const CSPFK028E string = "CSPFK028E Unable to patch k8s secret '%s'"
// Conjur
const CSPFK031E string = "CSPFK031E Failed to load Conjur config. Reason: %s"
const CSPFK032E string = "CSPFK032E Failed to create Conjur client from token. Reason: %s"
const CSPFK033E string = "CSPFK033E Failed to create Conjur client"
const CSPFK034E string = "CSPFK034E Failed to retrieve Conjur secrets. Reason: %s"
const CSPFK035E string = "CSPFK035E Failed to parse Conjur variable ID"
const CSPFK036E string = "CSPFK036E Variable ID '%s' is not in the format '<account>:variable:<variable_id>'"
const CSPFK037E string = "CSPFK037E Failed to parse Conjur variable IDs"
// General
const CSPFK038E string = "CSPFK038E Retransmission backoff exhausted" | pkg/log/messages/error_messages.go | 0.508056 | 0.556701 | error_messages.go | starcoder |
package miscmodule
import (
"database/sql"
"strings"
"time"
"github.com/bwmarrin/discordgo"
bot "github.com/erikmcclure/sweetiebot/sweetiebot"
)
// MiscModule contains miscellaneous commands
type MiscModule struct {
}
// Name of the module
func (w *MiscModule) Name() string {
return "Miscellaneous"
}
// New instance of MiscModule
func New() *MiscModule {
return &MiscModule{}
}
// Commands in the module
func (w *MiscModule) Commands() []bot.Command {
return []bot.Command{
&lastSeenCommand{},
&searchCommand{statements: make(map[string][]*sql.Stmt)},
&rollCommand{},
&showrollCommand{},
&snowflakeTimeCommand{},
&pollCommand{},
}
}
// Description of the module
func (w *MiscModule) Description(info *bot.GuildInfo) string {
return "A collection of miscellaneous commands that don't belong to a module. Review the help information on each command for more details."
}
type lastSeenCommand struct {
}
func (c *lastSeenCommand) Info() *bot.CommandInfo {
return &bot.CommandInfo{
Name: "LastSeen",
Usage: "Returns when a user was last seen.",
}
}
func (c *lastSeenCommand) Process(args []string, msg *discordgo.Message, indices []int, info *bot.GuildInfo) (string, bool, *discordgo.MessageEmbed) {
if !info.Bot.DB.CheckStatus() {
return "```\nA temporary database outage is preventing this command from being executed.```", false, nil
}
if len(indices) < 1 {
return "```\nYou have to give me someone to look for!```", false, nil
}
arg := msg.Content[indices[0]:]
IDs := info.FindUsername(arg)
if len(IDs) == 0 { // no matches!
return "```\nError: Could not find any usernames or aliases matching " + arg + "!```", false, nil
}
if len(IDs) > 1 {
return "```\nCould be any of the following users or their aliases:\n" + strings.Join(info.IDsToUsernames(IDs, true), "\n") + "```", len(IDs) > 5, nil
}
u, lastseen, _ := info.Bot.DB.GetMember(IDs[0], bot.SBatoi(info.ID))
if u == nil {
return "```\nError: User does not exist!```", false, nil
}
nick := u.User.Username
if len(u.Nick) > 0 {
nick = u.Nick
}
return "```\n" + nick + " last seen " + bot.TimeDiff(bot.GetTimestamp(msg).Sub(lastseen)) + " ago.```", false, nil
}
func (c *lastSeenCommand) Usage(info *bot.GuildInfo) *bot.CommandUsage {
return &bot.CommandUsage{
Desc: "Returns when a user was last seen on discord, which is usually their last status change.",
Params: []bot.CommandUsageParam{
{Name: "@user", Desc: "Either a ping for the user, their username, or their nickname.", Optional: false},
},
}
}
type snowflakeTimeCommand struct {
}
func (c *snowflakeTimeCommand) Info() *bot.CommandInfo {
return &bot.CommandInfo{
Name: "SnowflakeTime",
Usage: "Returns when a snowflake ID was created.",
}
}
func (c *snowflakeTimeCommand) Process(args []string, msg *discordgo.Message, indices []int, info *bot.GuildInfo) (string, bool, *discordgo.MessageEmbed) {
if len(args) < 1 {
return "```\nYou have to give me an ID!```", false, nil
}
ID := bot.SBatoi(bot.StripPing(args[0]))
if ID == 0 {
return "```\nInvalid snowflake ID.```", false, nil
}
t := bot.SnowflakeTime(ID)
tz := info.GetTimezone(bot.DiscordUser(msg.Author.ID))
return t.In(tz).Format(time.RFC1123), false, nil
}
func (c *snowflakeTimeCommand) Usage(info *bot.GuildInfo) *bot.CommandUsage {
return &bot.CommandUsage{
Desc: "Given a discord snowflake ID, returns when that ID was created.",
Params: []bot.CommandUsageParam{
{Name: "ID", Desc: "Any unique ID used by discord (these are called snowflake IDs)", Optional: false},
},
}
}
func (c *snowflakeTimeCommand) UsageShort() string { return "Returns when a snowflake ID was created." } | miscmodule/MiscModule.go | 0.62498 | 0.505493 | MiscModule.go | starcoder |
package main
import "math"
/*
4XY
VIBRATO means to "oscillate the sample pitch using a particular waveform
with amplitude yyyy notes, such that (xxxx * speed)/64 full oscillations
occur in the line". The waveform to use in vibrating is set using effect
E4 (see below). By placing vibrato effects on consecutive lines, the
vibrato effect can be sustained for any length of time. If either xxxx
or yyyy are 0, then values from the most recent prior vibrato will be
used.
An example is: Note C-3, with xxxx=12 and yyyy=1 when speed=8. This will
play tones around C-3, vibrating through D-3 and B-2 to C-3 again
(amplitude yyyy is 1), with (12*8)/64 = 1.5 full oscillations per line.
8 /
(x*sp)/64 = 2𝛑
Please see effect E4 for the waveform to use for vibrating.
FIXME: notes or HALF-NOTES (SEMITONES)?
7XY
TREMOLO means to "oscillate the sample volume using a particular waveform
with amplitude yyyy*(speed-1), such that (xxxx*speed)/64 full
oscillations occur in the line". The waveform to use to oscillate is set
using the effect E7 (see below). By placing tremolo effects on
consecutive lines, the tremolo effect can be sustained for any length of
time. If either xxxx or yyyy are 0, then values from the most recent
prior tremolo will be used.
The usage of this effect is similar to that of effect 4:Vibrato.
*/
// WaveformType is the type of the envelope waveform used for vibrato/tremolo
type WaveformType int
const (
// Sine - sine waveform
Sine WaveformType = iota
// RampDown - "sawtooth" waveform
RampDown
// Square - square wave
Square
// Random - select one of Sine/RampDown/Square randomly
Random
)
// EffectWaveform contains the parameters for a waveform assigned to an effect
type EffectWaveform struct {
SamplesPerTick int
Active bool
Type WaveformType
Retrig bool
CurType WaveformType
Pos float64
Step float64
Amplitude float64
}
// DoStep gets the next value for our waveform
func (ew *EffectWaveform) DoStep() int {
if !ew.Active {
return 0
}
ew.Pos += ew.Step
switch ew.CurType {
case Sine:
return int(math.Round(ew.Amplitude * math.Sin(ew.Pos)))
case Square, RampDown: // FIXME implement RampDown!
if math.Sin(ew.Pos) > 0 {
return int(ew.Amplitude)
}
return int(-ew.Amplitude)
}
return 0
}
func (ew *EffectWaveform) initWaveform(X, amplitude int) {
ew.Active = true
if ew.Retrig {
ew.Pos = 0
}
if X > 0 && amplitude > 0 {
ew.CurType = ew.Type
if ew.Type == Random {
ew.CurType = Sine // TODO: really set type randomly!
}
ew.Step = (math.Pi * float64(X)) / (32.0 * float64(ew.SamplesPerTick))
ew.Amplitude = float64(amplitude)
}
}
// InitTremoloWaveform (re)initializes a waveform for a tremolo (volume) effect at the beginning of a new note
func (ew *EffectWaveform) InitTremoloWaveform(X, Y int) {
ew.initWaveform(X, Y)
}
// InitVibratoWaveform initializes a waveform for a vibrato (pitch) effect
func (ew *EffectWaveform) InitVibratoWaveform(X, Y, period int, ins Instrument) {
ew.initWaveform(X, ins.GetPeriodDelta(period, Y))
}
// DecodeWaveformType sets the type of an EffectWaveform from a "set waveform" command parameter par
func (ew *EffectWaveform) DecodeWaveformType(par int) {
ew.Retrig = par < 4
switch par {
case 0, 4:
ew.Type = Sine
case 1, 5:
ew.Type = RampDown
case 2, 6:
ew.Type = Square
case 3, 7:
ew.Type = Random
}
}
// NewEffectWaveform creates a new EffectWaveform
func NewEffectWaveform(SamplesPerTick int) (ew EffectWaveform) {
ew.SamplesPerTick = SamplesPerTick
ew.DecodeWaveformType(0)
return
} | effectWaveform.go | 0.550607 | 0.479747 | effectWaveform.go | starcoder |
package types
// An interface and structure together that can turn any struct into a tree structure with parent/child relationships
// To use it, simply embed the TreeNode structure into another structure and call Init. This TreeNodeI structure will
// be convertable to the parent object
type TreeNodeI interface {
AddChildNode(TreeNodeI)
RemoveAllChildNodes()
RemoveChildNode(TreeNodeI)
ParentNode() TreeNodeI
SetParent(TreeNodeI)
TopNode() TreeNodeI
ChildNodes() []TreeNodeI
}
// A kind of mixin for anything that controls child controls, which are all controls, but also the top level form or page
// Creates a parent/child tree of controls that is used by the drawing code to draw the controls
type TreeNode struct {
self TreeNodeI
parent TreeNodeI
children []TreeNodeI
}
// To correctly get to the top node, the top node must know about itself
func (n *TreeNode) Init(self TreeNodeI) {
n.self = self
}
// addChildNode adds the given node as a child of the current node
func (n *TreeNode) AddChildNode(c TreeNodeI) {
if n.self == nil {
panic("Call Init before using the TreeNode to get the top node.")
}
if n.children == nil {
n.children = []TreeNodeI{c}
} else {
n.children = append(n.children, c)
}
c.SetParent(n.self)
}
// The central removal function. Manages the entire remove process. Other removal functions should call here.
func (n *TreeNode) RemoveChildNode(c TreeNodeI) {
for i, v := range n.children {
if v == c {
n.children = append(n.children[:i], n.children[i+1:]...) // remove found item from list
break
}
}
}
func (n *TreeNode) RemoveAllChildNodes() {
n.children = nil
}
func (n *TreeNode) ParentNode() TreeNodeI {
return n.parent
}
func (n *TreeNode) SetParent(p TreeNodeI) {
n.parent = p
}
// Return the top node in the hierarchy.
func (n *TreeNode) TopNode() TreeNodeI {
if n.self == nil {
panic("Call Init before using the TreeNode to get the top node.")
}
var f TreeNodeI = n.self
for f.ParentNode() != nil {
f = f.ParentNode()
}
return f
}
func (n *TreeNode) ChildNodes() []TreeNodeI {
return n.children
} | ideas/types/treeNode.go | 0.708616 | 0.522385 | treeNode.go | starcoder |
package field
import (
"gorm.io/gorm/clause"
)
type Int Field
func (field Int) Eq(value int) Expr {
return expr{e: clause.Eq{Column: field.RawExpr(), Value: value}}
}
func (field Int) Neq(value int) Expr {
return expr{e: clause.Neq{Column: field.RawExpr(), Value: value}}
}
func (field Int) Gt(value int) Expr {
return expr{e: clause.Gt{Column: field.RawExpr(), Value: value}}
}
func (field Int) Gte(value int) Expr {
return expr{e: clause.Gte{Column: field.RawExpr(), Value: value}}
}
func (field Int) Lt(value int) Expr {
return expr{e: clause.Lt{Column: field.RawExpr(), Value: value}}
}
func (field Int) Lte(value int) Expr {
return expr{e: clause.Lte{Column: field.RawExpr(), Value: value}}
}
func (field Int) In(values ...int) Expr {
return expr{e: clause.IN{Column: field.RawExpr(), Values: field.toSlice(values...)}}
}
func (field Int) NotIn(values ...int) Expr {
return expr{e: clause.Not(field.In(values...).expression())}
}
func (field Int) Between(left int, right int) Expr {
return field.between([]interface{}{left, right})
}
func (field Int) NotBetween(left int, right int) Expr {
return Not(field.Between(left, right))
}
func (field Int) Like(value int) Expr {
return expr{e: clause.Like{Column: field.RawExpr(), Value: value}}
}
func (field Int) NotLike(value int) Expr {
return expr{e: clause.Not(field.Like(value).expression())}
}
func (field Int) Add(value int) Int {
return Int{field.add(value)}
}
func (field Int) Sub(value int) Int {
return Int{field.sub(value)}
}
func (field Int) Mul(value int) Int {
return Int{field.mul(value)}
}
func (field Int) Div(value int) Int {
return Int{field.div(value)}
}
func (field Int) Mod(value int) Int {
return Int{field.mod(value)}
}
func (field Int) FloorDiv(value int) Int {
return Int{field.floorDiv(value)}
}
func (field Int) RightShift(value int) Int {
return Int{field.rightShift(value)}
}
func (field Int) LeftShift(value int) Int {
return Int{field.leftShift(value)}
}
func (field Int) BitXor(value int) Int {
return Int{field.bitXor(value)}
}
func (field Int) BitAnd(value int) Int {
return Int{field.bitAnd(value)}
}
func (field Int) BitOr(value int) Int {
return Int{field.bitOr(value)}
}
func (field Int) BitFlip() Int {
return Int{field.bitFlip()}
}
func (field Int) Value(value int) AssignExpr {
return field.value(value)
}
func (field Int) Zero() AssignExpr {
return field.value(0)
}
func (field Int) toSlice(values ...int) []interface{} {
slice := make([]interface{}, len(values))
for i, v := range values {
slice[i] = v
}
return slice
}
type Int8 Int
func (field Int8) Eq(value int8) Expr {
return expr{e: clause.Eq{Column: field.RawExpr(), Value: value}}
}
func (field Int8) Neq(value int8) Expr {
return expr{e: clause.Neq{Column: field.RawExpr(), Value: value}}
}
func (field Int8) Gt(value int8) Expr {
return expr{e: clause.Gt{Column: field.RawExpr(), Value: value}}
}
func (field Int8) Gte(value int8) Expr {
return expr{e: clause.Gte{Column: field.RawExpr(), Value: value}}
}
func (field Int8) Lt(value int8) Expr {
return expr{e: clause.Lt{Column: field.RawExpr(), Value: value}}
}
func (field Int8) Lte(value int8) Expr {
return expr{e: clause.Lte{Column: field.RawExpr(), Value: value}}
}
func (field Int8) In(values ...int8) Expr {
return expr{e: clause.IN{Column: field.RawExpr(), Values: field.toSlice(values...)}}
}
func (field Int8) NotIn(values ...int8) Expr {
return expr{e: clause.Not(field.In(values...).expression())}
}
func (field Int8) Between(left int8, right int8) Expr {
return field.between([]interface{}{left, right})
}
func (field Int8) NotBetween(left int8, right int8) Expr {
return Not(field.Between(left, right))
}
func (field Int8) Like(value int8) Expr {
return expr{e: clause.Like{Column: field.RawExpr(), Value: value}}
}
func (field Int8) NotLike(value int8) Expr {
return expr{e: clause.Not(field.Like(value).expression())}
}
func (field Int8) Add(value int8) Int8 {
return Int8{field.add(value)}
}
func (field Int8) Sub(value int8) Int8 {
return Int8{field.sub(value)}
}
func (field Int8) Mul(value int8) Int8 {
return Int8{field.mul(value)}
}
func (field Int8) Div(value int8) Int8 {
return Int8{field.div(value)}
}
func (field Int8) Mod(value int8) Int8 {
return Int8{field.mod(value)}
}
func (field Int8) FloorDiv(value int8) Int8 {
return Int8{field.floorDiv(value)}
}
func (field Int8) RightShift(value int8) Int8 {
return Int8{field.rightShift(value)}
}
func (field Int8) LeftShift(value int8) Int8 {
return Int8{field.leftShift(value)}
}
func (field Int8) BitXor(value int8) Int8 {
return Int8{field.bitXor(value)}
}
func (field Int8) BitAnd(value int8) Int8 {
return Int8{field.bitAnd(value)}
}
func (field Int8) BitOr(value int8) Int8 {
return Int8{field.bitOr(value)}
}
func (field Int8) BitFlip() Int8 {
return Int8{field.bitFlip()}
}
func (field Int8) Value(value int8) AssignExpr {
return field.value(value)
}
func (field Int8) Zero() AssignExpr {
return field.value(0)
}
func (field Int8) toSlice(values ...int8) []interface{} {
slice := make([]interface{}, len(values))
for i, v := range values {
slice[i] = v
}
return slice
}
type Int16 Int
func (field Int16) Eq(value int16) Expr {
return expr{e: clause.Eq{Column: field.RawExpr(), Value: value}}
}
func (field Int16) Neq(value int16) Expr {
return expr{e: clause.Neq{Column: field.RawExpr(), Value: value}}
}
func (field Int16) Gt(value int16) Expr {
return expr{e: clause.Gt{Column: field.RawExpr(), Value: value}}
}
func (field Int16) Gte(value int16) Expr {
return expr{e: clause.Gte{Column: field.RawExpr(), Value: value}}
}
func (field Int16) Lt(value int16) Expr {
return expr{e: clause.Lt{Column: field.RawExpr(), Value: value}}
}
func (field Int16) Lte(value int16) Expr {
return expr{e: clause.Lte{Column: field.RawExpr(), Value: value}}
}
func (field Int16) In(values ...int16) Expr {
return expr{e: clause.IN{Column: field.RawExpr(), Values: field.toSlice(values...)}}
}
func (field Int16) NotIn(values ...int16) Expr {
return expr{e: clause.Not(field.In(values...).expression())}
}
func (field Int16) Between(left int16, right int16) Expr {
return field.between([]interface{}{left, right})
}
func (field Int16) NotBetween(left int16, right int16) Expr {
return Not(field.Between(left, right))
}
func (field Int16) Like(value int16) Expr {
return expr{e: clause.Like{Column: field.RawExpr(), Value: value}}
}
func (field Int16) NotLike(value int16) Expr {
return expr{e: clause.Not(field.Like(value).expression())}
}
func (field Int16) Add(value int16) Int16 {
return Int16{field.add(value)}
}
func (field Int16) Sub(value int16) Int16 {
return Int16{field.sub(value)}
}
func (field Int16) Mul(value int16) Int16 {
return Int16{field.mul(value)}
}
func (field Int16) Div(value int16) Int16 {
return Int16{field.div(value)}
}
func (field Int16) Mod(value int16) Int16 {
return Int16{field.mod(value)}
}
func (field Int16) FloorDiv(value int16) Int16 {
return Int16{field.floorDiv(value)}
}
func (field Int16) RightShift(value int16) Int16 {
return Int16{field.rightShift(value)}
}
func (field Int16) LeftShift(value int16) Int16 {
return Int16{field.leftShift(value)}
}
func (field Int16) BitXor(value int16) Int16 {
return Int16{field.bitXor(value)}
}
func (field Int16) BitAnd(value int16) Int16 {
return Int16{field.bitAnd(value)}
}
func (field Int16) BitOr(value int16) Int16 {
return Int16{field.bitOr(value)}
}
func (field Int16) BitFlip() Int16 {
return Int16{field.bitFlip()}
}
func (field Int16) Value(value int16) AssignExpr {
return field.value(value)
}
func (field Int16) Zero() AssignExpr {
return field.value(0)
}
func (field Int16) toSlice(values ...int16) []interface{} {
slice := make([]interface{}, len(values))
for i, v := range values {
slice[i] = v
}
return slice
}
type Int32 Int
func (field Int32) Eq(value int32) Expr {
return expr{e: clause.Eq{Column: field.RawExpr(), Value: value}}
}
func (field Int32) Neq(value int32) Expr {
return expr{e: clause.Neq{Column: field.RawExpr(), Value: value}}
}
func (field Int32) Gt(value int32) Expr {
return expr{e: clause.Gt{Column: field.RawExpr(), Value: value}}
}
func (field Int32) Gte(value int32) Expr {
return expr{e: clause.Gte{Column: field.RawExpr(), Value: value}}
}
func (field Int32) Lt(value int32) Expr {
return expr{e: clause.Lt{Column: field.RawExpr(), Value: value}}
}
func (field Int32) Lte(value int32) Expr {
return expr{e: clause.Lte{Column: field.RawExpr(), Value: value}}
}
func (field Int32) In(values ...int32) Expr {
return expr{e: clause.IN{Column: field.RawExpr(), Values: field.toSlice(values...)}}
}
func (field Int32) NotIn(values ...int32) Expr {
return expr{e: clause.Not(field.In(values...).expression())}
}
func (field Int32) Between(left int32, right int32) Expr {
return field.between([]interface{}{left, right})
}
func (field Int32) NotBetween(left int32, right int32) Expr {
return Not(field.Between(left, right))
}
func (field Int32) Like(value int32) Expr {
return expr{e: clause.Like{Column: field.RawExpr(), Value: value}}
}
func (field Int32) NotLike(value int32) Expr {
return expr{e: clause.Not(field.Like(value).expression())}
}
func (field Int32) Add(value int32) Int32 {
return Int32{field.add(value)}
}
func (field Int32) Sub(value int32) Int32 {
return Int32{field.sub(value)}
}
func (field Int32) Mul(value int32) Int32 {
return Int32{field.mul(value)}
}
func (field Int32) Div(value int32) Int32 {
return Int32{field.div(value)}
}
func (field Int32) Mod(value int32) Int32 {
return Int32{field.mod(value)}
}
func (field Int32) FloorDiv(value int32) Int32 {
return Int32{field.floorDiv(value)}
}
func (field Int32) RightShift(value int32) Int32 {
return Int32{field.rightShift(value)}
}
func (field Int32) LeftShift(value int32) Int32 {
return Int32{field.leftShift(value)}
}
func (field Int32) BitXor(value int32) Int32 {
return Int32{field.bitXor(value)}
}
func (field Int32) BitAnd(value int32) Int32 {
return Int32{field.bitAnd(value)}
}
func (field Int32) BitOr(value int32) Int32 {
return Int32{field.bitOr(value)}
}
func (field Int32) BitFlip() Int32 {
return Int32{field.bitFlip()}
}
func (field Int32) Value(value int32) AssignExpr {
return field.value(value)
}
func (field Int32) Zero() AssignExpr {
return field.value(0)
}
func (field Int32) toSlice(values ...int32) []interface{} {
slice := make([]interface{}, len(values))
for i, v := range values {
slice[i] = v
}
return slice
}
type Int64 Int
func (field Int64) Eq(value int64) Expr {
return expr{e: clause.Eq{Column: field.RawExpr(), Value: value}}
}
func (field Int64) Neq(value int64) Expr {
return expr{e: clause.Neq{Column: field.RawExpr(), Value: value}}
}
func (field Int64) Gt(value int64) Expr {
return expr{e: clause.Gt{Column: field.RawExpr(), Value: value}}
}
func (field Int64) Gte(value int64) Expr {
return expr{e: clause.Gte{Column: field.RawExpr(), Value: value}}
}
func (field Int64) Lt(value int64) Expr {
return expr{e: clause.Lt{Column: field.RawExpr(), Value: value}}
}
func (field Int64) Lte(value int64) Expr {
return expr{e: clause.Lte{Column: field.RawExpr(), Value: value}}
}
func (field Int64) In(values ...int64) Expr {
return expr{e: clause.IN{Column: field.RawExpr(), Values: field.toSlice(values...)}}
}
func (field Int64) NotIn(values ...int64) Expr {
return expr{e: clause.Not(field.In(values...).expression())}
}
func (field Int64) Between(left int64, right int64) Expr {
return field.between([]interface{}{left, right})
}
func (field Int64) NotBetween(left int64, right int64) Expr {
return Not(field.Between(left, right))
}
func (field Int64) Like(value int64) Expr {
return expr{e: clause.Like{Column: field.RawExpr(), Value: value}}
}
func (field Int64) NotLike(value int64) Expr {
return expr{e: clause.Not(field.Like(value).expression())}
}
func (field Int64) Add(value int64) Int64 {
return Int64{field.add(value)}
}
func (field Int64) Sub(value int64) Int64 {
return Int64{field.sub(value)}
}
func (field Int64) Mul(value int64) Int64 {
return Int64{field.mul(value)}
}
func (field Int64) Div(value int64) Int64 {
return Int64{field.div(value)}
}
func (field Int64) Mod(value int64) Int64 {
return Int64{field.mod(value)}
}
func (field Int64) FloorDiv(value int64) Int64 {
return Int64{field.floorDiv(value)}
}
func (field Int64) RightShift(value int64) Int64 {
return Int64{field.rightShift(value)}
}
func (field Int64) LeftShift(value int64) Int64 {
return Int64{field.leftShift(value)}
}
func (field Int64) BitXor(value int64) Int64 {
return Int64{field.bitXor(value)}
}
func (field Int64) BitAnd(value int64) Int64 {
return Int64{field.bitAnd(value)}
}
func (field Int64) BitOr(value int64) Int64 {
return Int64{field.bitOr(value)}
}
func (field Int64) BitFlip() Int64 {
return Int64{field.bitFlip()}
}
func (field Int64) Value(value int64) AssignExpr {
return field.value(value)
}
func (field Int64) Zero() AssignExpr {
return field.value(0)
}
func (field Int64) toSlice(values ...int64) []interface{} {
slice := make([]interface{}, len(values))
for i, v := range values {
slice[i] = v
}
return slice
}
type Uint Int
func (field Uint) Eq(value uint) Expr {
return expr{e: clause.Eq{Column: field.RawExpr(), Value: value}}
}
func (field Uint) Neq(value uint) Expr {
return expr{e: clause.Neq{Column: field.RawExpr(), Value: value}}
}
func (field Uint) Gt(value uint) Expr {
return expr{e: clause.Gt{Column: field.RawExpr(), Value: value}}
}
func (field Uint) Gte(value uint) Expr {
return expr{e: clause.Gte{Column: field.RawExpr(), Value: value}}
}
func (field Uint) Lt(value uint) Expr {
return expr{e: clause.Lt{Column: field.RawExpr(), Value: value}}
}
func (field Uint) Lte(value uint) Expr {
return expr{e: clause.Lte{Column: field.RawExpr(), Value: value}}
}
func (field Uint) In(values ...uint) Expr {
return expr{e: clause.IN{Column: field.RawExpr(), Values: field.toSlice(values...)}}
}
func (field Uint) NotIn(values ...uint) Expr {
return expr{e: clause.Not(field.In(values...).expression())}
}
func (field Uint) Between(left uint, right uint) Expr {
return field.between([]interface{}{left, right})
}
func (field Uint) NotBetween(left uint, right uint) Expr {
return Not(field.Between(left, right))
}
func (field Uint) Like(value uint) Expr {
return expr{e: clause.Like{Column: field.RawExpr(), Value: value}}
}
func (field Uint) NotLike(value uint) Expr {
return expr{e: clause.Not(field.Like(value).expression())}
}
func (field Uint) Add(value uint) Uint {
return Uint{field.add(value)}
}
func (field Uint) Sub(value uint) Uint {
return Uint{field.sub(value)}
}
func (field Uint) Mul(value uint) Uint {
return Uint{field.mul(value)}
}
func (field Uint) Div(value uint) Uint {
return Uint{field.mul(value)}
}
func (field Uint) Mod(value uint) Uint {
return Uint{field.mod(value)}
}
func (field Uint) FloorDiv(value uint) Uint {
return Uint{field.floorDiv(value)}
}
func (field Uint) RightShift(value uint) Uint {
return Uint{field.rightShift(value)}
}
func (field Uint) LeftShift(value uint) Uint {
return Uint{field.leftShift(value)}
}
func (field Uint) BitXor(value uint) Uint {
return Uint{field.bitXor(value)}
}
func (field Uint) BitAnd(value uint) Uint {
return Uint{field.bitAnd(value)}
}
func (field Uint) BitOr(value uint) Uint {
return Uint{field.bitOr(value)}
}
func (field Uint) BitFlip() Uint {
return Uint{field.bitFlip()}
}
func (field Uint) Value(value uint) AssignExpr {
return field.value(value)
}
func (field Uint) Zero() AssignExpr {
return field.value(0)
}
func (field Uint) toSlice(values ...uint) []interface{} {
slice := make([]interface{}, len(values))
for i, v := range values {
slice[i] = v
}
return slice
}
type Uint8 Int
func (field Uint8) Eq(value uint8) Expr {
return expr{e: clause.Eq{Column: field.RawExpr(), Value: value}}
}
func (field Uint8) Neq(value uint8) Expr {
return expr{e: clause.Neq{Column: field.RawExpr(), Value: value}}
}
func (field Uint8) Gt(value uint8) Expr {
return expr{e: clause.Gt{Column: field.RawExpr(), Value: value}}
}
func (field Uint8) Gte(value uint8) Expr {
return expr{e: clause.Gte{Column: field.RawExpr(), Value: value}}
}
func (field Uint8) Lt(value uint8) Expr {
return expr{e: clause.Lt{Column: field.RawExpr(), Value: value}}
}
func (field Uint8) Lte(value uint8) Expr {
return expr{e: clause.Lte{Column: field.RawExpr(), Value: value}}
}
func (field Uint8) In(values ...uint8) Expr {
return expr{e: clause.IN{Column: field.RawExpr(), Values: field.toSlice(values...)}}
}
func (field Uint8) NotIn(values ...uint8) Expr {
return expr{e: clause.Not(field.In(values...).expression())}
}
func (field Uint8) Between(left uint8, right uint8) Expr {
return field.between([]interface{}{left, right})
}
func (field Uint8) NotBetween(left uint8, right uint8) Expr {
return Not(field.Between(left, right))
}
func (field Uint8) Like(value uint8) Expr {
return expr{e: clause.Like{Column: field.RawExpr(), Value: value}}
}
func (field Uint8) NotLike(value uint8) Expr {
return expr{e: clause.Not(field.Like(value).expression())}
}
func (field Uint8) Add(value uint8) Uint8 {
return Uint8{field.add(value)}
}
func (field Uint8) Sub(value uint8) Uint8 {
return Uint8{field.sub(value)}
}
func (field Uint8) Mul(value uint8) Uint8 {
return Uint8{field.mul(value)}
}
func (field Uint8) Div(value uint8) Uint8 {
return Uint8{field.mul(value)}
}
func (field Uint8) Mod(value uint8) Uint8 {
return Uint8{field.mod(value)}
}
func (field Uint8) FloorDiv(value uint8) Uint8 {
return Uint8{field.floorDiv(value)}
}
func (field Uint8) RightShift(value uint8) Uint8 {
return Uint8{field.rightShift(value)}
}
func (field Uint8) LeftShift(value uint8) Uint8 {
return Uint8{field.leftShift(value)}
}
func (field Uint8) BitXor(value uint8) Uint8 {
return Uint8{field.bitXor(value)}
}
func (field Uint8) BitAnd(value uint8) Uint8 {
return Uint8{field.bitAnd(value)}
}
func (field Uint8) BitOr(value uint8) Uint8 {
return Uint8{field.bitOr(value)}
}
func (field Uint8) BitFlip() Uint8 {
return Uint8{field.bitFlip()}
}
func (field Uint8) Value(value uint8) AssignExpr {
return field.value(value)
}
func (field Uint8) Zero() AssignExpr {
return field.value(0)
}
func (field Uint8) toSlice(values ...uint8) []interface{} {
slice := make([]interface{}, len(values))
for i, v := range values {
slice[i] = v
}
return slice
}
type Uint16 Int
func (field Uint16) Eq(value uint16) Expr {
return expr{e: clause.Eq{Column: field.RawExpr(), Value: value}}
}
func (field Uint16) Neq(value uint16) Expr {
return expr{e: clause.Neq{Column: field.RawExpr(), Value: value}}
}
func (field Uint16) Gt(value uint16) Expr {
return expr{e: clause.Gt{Column: field.RawExpr(), Value: value}}
}
func (field Uint16) Gte(value uint16) Expr {
return expr{e: clause.Gte{Column: field.RawExpr(), Value: value}}
}
func (field Uint16) Lt(value uint16) Expr {
return expr{e: clause.Lt{Column: field.RawExpr(), Value: value}}
}
func (field Uint16) Lte(value uint16) Expr {
return expr{e: clause.Lte{Column: field.RawExpr(), Value: value}}
}
func (field Uint16) In(values ...uint16) Expr {
return expr{e: clause.IN{Column: field.RawExpr(), Values: field.toSlice(values...)}}
}
func (field Uint16) NotIn(values ...uint16) Expr {
return expr{e: clause.Not(field.In(values...).expression())}
}
func (field Uint16) Between(left uint16, right uint16) Expr {
return field.between([]interface{}{left, right})
}
func (field Uint16) NotBetween(left uint16, right uint16) Expr {
return Not(field.Between(left, right))
}
func (field Uint16) Like(value uint16) Expr {
return expr{e: clause.Like{Column: field.RawExpr(), Value: value}}
}
func (field Uint16) NotLike(value uint16) Expr {
return expr{e: clause.Not(field.Like(value).expression())}
}
func (field Uint16) Add(value uint16) Uint16 {
return Uint16{field.add(value)}
}
func (field Uint16) Sub(value uint16) Uint16 {
return Uint16{field.sub(value)}
}
func (field Uint16) Mul(value uint16) Uint16 {
return Uint16{field.mul(value)}
}
func (field Uint16) Div(value uint16) Uint16 {
return Uint16{field.mul(value)}
}
func (field Uint16) Mod(value uint16) Uint16 {
return Uint16{field.mod(value)}
}
func (field Uint16) FloorDiv(value uint16) Uint16 {
return Uint16{field.floorDiv(value)}
}
func (field Uint16) RightShift(value uint16) Uint16 {
return Uint16{field.rightShift(value)}
}
func (field Uint16) LeftShift(value uint16) Uint16 {
return Uint16{field.leftShift(value)}
}
func (field Uint16) BitXor(value uint16) Uint16 {
return Uint16{field.bitXor(value)}
}
func (field Uint16) BitAnd(value uint16) Uint16 {
return Uint16{field.bitAnd(value)}
}
func (field Uint16) BitOr(value uint16) Uint16 {
return Uint16{field.bitOr(value)}
}
func (field Uint16) BitFlip() Uint16 {
return Uint16{field.bitFlip()}
}
func (field Uint16) Value(value uint16) AssignExpr {
return field.value(value)
}
func (field Uint16) Zero() AssignExpr {
return field.value(0)
}
func (field Uint16) toSlice(values ...uint16) []interface{} {
slice := make([]interface{}, len(values))
for i, v := range values {
slice[i] = v
}
return slice
}
type Uint32 Int
func (field Uint32) Eq(value uint32) Expr {
return expr{e: clause.Eq{Column: field.RawExpr(), Value: value}}
}
func (field Uint32) Neq(value uint32) Expr {
return expr{e: clause.Neq{Column: field.RawExpr(), Value: value}}
}
func (field Uint32) Gt(value uint32) Expr {
return expr{e: clause.Gt{Column: field.RawExpr(), Value: value}}
}
func (field Uint32) Gte(value uint32) Expr {
return expr{e: clause.Gte{Column: field.RawExpr(), Value: value}}
}
func (field Uint32) Lt(value uint32) Expr {
return expr{e: clause.Lt{Column: field.RawExpr(), Value: value}}
}
func (field Uint32) Lte(value uint32) Expr {
return expr{e: clause.Lte{Column: field.RawExpr(), Value: value}}
}
func (field Uint32) In(values ...uint32) Expr {
return expr{e: clause.IN{Column: field.RawExpr(), Values: field.toSlice(values...)}}
}
func (field Uint32) NotIn(values ...uint32) Expr {
return expr{e: clause.Not(field.In(values...).expression())}
}
func (field Uint32) Between(left uint32, right uint32) Expr {
return field.between([]interface{}{left, right})
}
func (field Uint32) NotBetween(left uint32, right uint32) Expr {
return Not(field.Between(left, right))
}
func (field Uint32) Like(value uint32) Expr {
return expr{e: clause.Like{Column: field.RawExpr(), Value: value}}
}
func (field Uint32) NotLike(value uint32) Expr {
return expr{e: clause.Not(field.Like(value).expression())}
}
func (field Uint32) Add(value uint32) Uint32 {
return Uint32{field.add(value)}
}
func (field Uint32) Sub(value uint32) Uint32 {
return Uint32{field.sub(value)}
}
func (field Uint32) Mul(value uint32) Uint32 {
return Uint32{field.mul(value)}
}
func (field Uint32) Div(value uint32) Uint32 {
return Uint32{field.mul(value)}
}
func (field Uint32) Mod(value uint32) Uint32 {
return Uint32{field.mod(value)}
}
func (field Uint32) FloorDiv(value uint32) Uint32 {
return Uint32{field.floorDiv(value)}
}
func (field Uint32) RightShift(value uint32) Uint32 {
return Uint32{field.rightShift(value)}
}
func (field Uint32) LeftShift(value uint32) Uint32 {
return Uint32{field.leftShift(value)}
}
func (field Uint32) BitXor(value uint32) Uint32 {
return Uint32{field.bitXor(value)}
}
func (field Uint32) BitAnd(value uint32) Uint32 {
return Uint32{field.bitAnd(value)}
}
func (field Uint32) BitOr(value uint32) Uint32 {
return Uint32{field.bitOr(value)}
}
func (field Uint32) BitFlip() Uint32 {
return Uint32{field.bitFlip()}
}
func (field Uint32) Value(value uint32) AssignExpr {
return field.value(value)
}
func (field Uint32) Zero() AssignExpr {
return field.value(0)
}
func (field Uint32) toSlice(values ...uint32) []interface{} {
slice := make([]interface{}, len(values))
for i, v := range values {
slice[i] = v
}
return slice
}
type Uint64 Int
func (field Uint64) Eq(value uint64) Expr {
return expr{e: clause.Eq{Column: field.RawExpr(), Value: value}}
}
func (field Uint64) Neq(value uint64) Expr {
return expr{e: clause.Neq{Column: field.RawExpr(), Value: value}}
}
func (field Uint64) Gt(value uint64) Expr {
return expr{e: clause.Gt{Column: field.RawExpr(), Value: value}}
}
func (field Uint64) Gte(value uint64) Expr {
return expr{e: clause.Gte{Column: field.RawExpr(), Value: value}}
}
func (field Uint64) Lt(value uint64) Expr {
return expr{e: clause.Lt{Column: field.RawExpr(), Value: value}}
}
func (field Uint64) Lte(value uint64) Expr {
return expr{e: clause.Lte{Column: field.RawExpr(), Value: value}}
}
func (field Uint64) In(values ...uint64) Expr {
return expr{e: clause.IN{Column: field.RawExpr(), Values: field.toSlice(values...)}}
}
func (field Uint64) NotIn(values ...uint64) Expr {
return expr{e: clause.Not(field.In(values...).expression())}
}
func (field Uint64) Between(left uint64, right uint64) Expr {
return field.between([]interface{}{left, right})
}
func (field Uint64) NotBetween(left uint64, right uint64) Expr {
return Not(field.Between(left, right))
}
func (field Uint64) Like(value uint64) Expr {
return expr{e: clause.Like{Column: field.RawExpr(), Value: value}}
}
func (field Uint64) NotLike(value uint64) Expr {
return expr{e: clause.Not(field.Like(value).expression())}
}
func (field Uint64) Add(value uint64) Uint64 {
return Uint64{field.add(value)}
}
func (field Uint64) Sub(value uint64) Uint64 {
return Uint64{field.sub(value)}
}
func (field Uint64) Mul(value uint64) Uint64 {
return Uint64{field.mul(value)}
}
func (field Uint64) Div(value uint64) Uint64 {
return Uint64{field.mul(value)}
}
func (field Uint64) Mod(value uint64) Uint64 {
return Uint64{field.mod(value)}
}
func (field Uint64) FloorDiv(value uint64) Uint64 {
return Uint64{field.floorDiv(value)}
}
func (field Uint64) RightShift(value uint64) Uint64 {
return Uint64{field.rightShift(value)}
}
func (field Uint64) LeftShift(value uint64) Uint64 {
return Uint64{field.leftShift(value)}
}
func (field Uint64) BitXor(value uint64) Uint64 {
return Uint64{field.bitXor(value)}
}
func (field Uint64) BitAnd(value uint64) Uint64 {
return Uint64{field.bitAnd(value)}
}
func (field Uint64) BitOr(value uint64) Uint64 {
return Uint64{field.bitOr(value)}
}
func (field Uint64) BitFlip() Uint64 {
return Uint64{field.bitFlip()}
}
func (field Uint64) Value(value uint64) AssignExpr {
return field.value(value)
}
func (field Uint64) Zero() AssignExpr {
return field.value(0)
}
func (field Uint64) toSlice(values ...uint64) []interface{} {
slice := make([]interface{}, len(values))
for i, v := range values {
slice[i] = v
}
return slice
} | field/int.go | 0.771413 | 0.537041 | int.go | starcoder |
package manipulate
import (
"context"
"go.aporeto.io/elemental"
)
// Manipulator is the interface of a storage backend.
type Manipulator interface {
// RetrieveMany retrieves the a list of objects with the given elemental.Identity and put them in the given dest.
RetrieveMany(mctx Context, dest elemental.Identifiables) error
// Retrieve retrieves one or multiple elemental.Identifiables.
// In order to be retrievable, the elemental.Identifiable needs to have their Identifier correctly set.
Retrieve(mctx Context, object elemental.Identifiable) error
// Create creates a the given elemental.Identifiables.
Create(mctx Context, object elemental.Identifiable) error
// Update updates one or multiple elemental.Identifiables.
// In order to be updatable, the elemental.Identifiable needs to have their Identifier correctly set.
Update(mctx Context, object elemental.Identifiable) error
// Delete deletes one or multiple elemental.Identifiables.
// In order to be deletable, the elemental.Identifiable needs to have their Identifier correctly set.
Delete(mctx Context, object elemental.Identifiable) error
// DeleteMany deletes all objects of with the given identity or
// all the ones matching the filter in the given context.
DeleteMany(mctx Context, identity elemental.Identity) error
// Count returns the number of objects with the given identity.
Count(mctx Context, identity elemental.Identity) (int, error)
}
// A TransactionalManipulator is a Manipulator that handles transactions.
type TransactionalManipulator interface {
// Commit commits the given TransactionID.
Commit(id TransactionID) error
// Abort aborts the give TransactionID. It returns true if
// a transaction has been effectively aborted, otherwise it returns false.
Abort(id TransactionID) bool
Manipulator
}
// A FlushableManipulator is a manipulator that can flush its
// content to somewhere, like a file.
type FlushableManipulator interface {
// Flush flushes and empties the cache.
Flush(ctx context.Context) error
}
// A BufferedManipulator is a Manipulator with a local cache
type BufferedManipulator interface {
FlushableManipulator
Manipulator
}
// SubscriberStatus is the type of a subscriber status.
type SubscriberStatus int
// Various values of SubscriberEvent.
const (
SubscriberStatusInitialConnection SubscriberStatus = iota + 1
SubscriberStatusInitialConnectionFailure
SubscriberStatusReconnection
SubscriberStatusReconnectionFailure
SubscriberStatusDisconnection
SubscriberStatusFinalDisconnection
SubscriberStatusTokenRenewal
)
// A Subscriber is the interface to control a push event subscription.
type Subscriber interface {
// Start connects to the websocket and starts collecting events
// until the given context is canceled or any non communication error is
// received. The eventual error will be received in the Errors() channel.
// If not nil, the given push config will be applied right away.
Start(context.Context, *elemental.PushConfig)
// UpdateFilter updates the current push config.
UpdateFilter(*elemental.PushConfig)
// Events returns the events channel.
Events() chan *elemental.Event
// Errors returns the errors channel.
Errors() chan error
// Status returns the status channel.
Status() chan SubscriberStatus
}
// A TokenManager issues an renew tokens periodically.
type TokenManager interface {
// Issues isses a new token.
Issue(context.Context) (string, error)
// Run runs the token renewal job and published the new token in the
// given channel.
Run(ctx context.Context, tokenCh chan string)
} | manipulate.go | 0.668015 | 0.456713 | manipulate.go | starcoder |
The original Space-Saving algorithm:
https://icmi.cs.ucsb.edu/research/tech_reports/reports/2005-23.pdf
The Filtered Space-Saving enhancement:
http://www.l2f.inesc-id.pt/~fmmb/wiki/uploads/Work/misnis.ref0a.pdf
This implementation follows the algorithm of the FSS paper, but not the
suggested implementation. Specifically, we use a heap instead of a sorted list
of monitored items, and since we are also using a map to provide O(1) access on
update also don't need the c_i counters in the hash table.
Licensed under the MIT license.
*/
package topk
import (
"container/heap"
"fmt"
"io"
"sort"
"github.com/dgryski/go-metro"
"github.com/tinylib/msgp/msgp"
)
// Element is a TopK item
type Element struct {
Key string `json:"key"`
Count int `json:"count"`
Error int `json:"error"`
}
type elementsByCountDescending []Element
func (elts elementsByCountDescending) Len() int { return len(elts) }
func (elts elementsByCountDescending) Less(i, j int) bool {
return (elts[i].Count > elts[j].Count) || (elts[i].Count == elts[j].Count && elts[i].Key < elts[j].Key)
}
func (elts elementsByCountDescending) Swap(i, j int) { elts[i], elts[j] = elts[j], elts[i] }
type keys struct {
m map[string]int
elts []Element
}
func (tk *keys) EncodeMsgp(w *msgp.Writer) error {
if err := w.WriteMapHeader(uint32(len(tk.m))); err != nil {
return err
}
for k, v := range tk.m {
if err := w.WriteString(k); err != nil {
return err
}
if err := w.WriteInt(v); err != nil {
return err
}
}
if err := w.WriteArrayHeader(uint32(len(tk.elts))); err != nil {
return err
}
for _, e := range tk.elts {
if err := w.WriteString(e.Key); err != nil {
return err
}
if err := w.WriteInt(e.Count); err != nil {
return err
}
if err := w.WriteInt(e.Error); err != nil {
return err
}
}
return nil
}
func (tk *keys) DecodeMsp(r *msgp.Reader) error {
var (
err error
sz uint32
)
if sz, err = r.ReadMapHeader(); err != nil {
return err
}
tk.m = make(map[string]int, sz)
for i := uint32(0); i < sz; i++ {
key, err := r.ReadString()
if err != nil {
return err
}
val, err := r.ReadInt()
if err != nil {
return err
}
tk.m[key] = val
}
if sz, err = r.ReadArrayHeader(); err != nil {
return err
}
tk.elts = make([]Element, sz)
for i := range tk.elts {
if tk.elts[i].Key, err = r.ReadString(); err != nil {
return err
}
if tk.elts[i].Count, err = r.ReadInt(); err != nil {
return err
}
if tk.elts[i].Error, err = r.ReadInt(); err != nil {
return err
}
}
return nil
}
// Implement the container/heap interface
// Len ...
func (tk *keys) Len() int { return len(tk.elts) }
// Less ...
func (tk *keys) Less(i, j int) bool {
return (tk.elts[i].Count < tk.elts[j].Count) || (tk.elts[i].Count == tk.elts[j].Count && tk.elts[i].Error > tk.elts[j].Error)
}
func (tk *keys) Swap(i, j int) {
tk.elts[i], tk.elts[j] = tk.elts[j], tk.elts[i]
tk.m[tk.elts[i].Key] = i
tk.m[tk.elts[j].Key] = j
}
func (tk *keys) Push(x interface{}) {
e := x.(Element)
tk.m[e.Key] = len(tk.elts)
tk.elts = append(tk.elts, e)
}
func (tk *keys) Pop() interface{} {
var e Element
e, tk.elts = tk.elts[len(tk.elts)-1], tk.elts[:len(tk.elts)-1]
delete(tk.m, e.Key)
return e
}
// Stream calculates the TopK elements for a stream
type Stream struct {
n int
k keys
alphas []int
}
// New returns a Stream estimating the top n most frequent elements
func New(n int) *Stream {
return &Stream{
n: n,
k: keys{m: make(map[string]int, n), elts: make([]Element, 0, n)},
alphas: make([]int, n*6), // 6 is the multiplicative constant from the paper
}
}
func reduce(x uint64, n int) uint32 {
return uint32(uint64(uint32(x)) * uint64(n) >> 32)
}
// Insert adds an element to the stream to be tracked
// It returns an estimation for the just inserted element
func (s *Stream) Insert(x string, count int) Element {
xhash := reduce(metro.Hash64Str(x, 0), len(s.alphas))
// are we tracking this element?
if idx, ok := s.k.m[x]; ok {
s.k.elts[idx].Count += count
e := s.k.elts[idx]
heap.Fix(&s.k, idx)
return e
}
// can we track more elements?
if len(s.k.elts) < s.n {
// there is free space
e := Element{Key: x, Count: count}
heap.Push(&s.k, e)
return e
}
if s.alphas[xhash]+count < s.k.elts[0].Count {
e := Element{
Key: x,
Error: s.alphas[xhash],
Count: s.alphas[xhash] + count,
}
s.alphas[xhash] += count
return e
}
// replace the current minimum element
minElement := s.k.elts[0]
mkhash := reduce(metro.Hash64Str(minElement.Key, 0), len(s.alphas))
s.alphas[mkhash] = minElement.Count
e := Element{
Key: x,
Error: s.alphas[xhash],
Count: s.alphas[xhash] + count,
}
s.k.elts[0] = e
// we're not longer monitoring minKey
delete(s.k.m, minElement.Key)
// but 'x' is as array position 0
s.k.m[x] = 0
heap.Fix(&s.k, 0)
return e
}
// Merge ...
func (s *Stream) Merge(other *Stream) error {
if s.n != other.n {
return fmt.Errorf("expected stream of size n %d, got %d", s.n, other.n)
}
// merge the elements
eKeys := make(map[string]struct{})
eMap := make(map[string]Element)
for _, e := range s.k.elts {
eKeys[e.Key] = struct{}{}
}
for _, e := range other.k.elts {
eKeys[e.Key] = struct{}{}
}
for k := range eKeys {
idx1, ok1 := s.k.m[k]
idx2, ok2 := other.k.m[k]
xhash := reduce(metro.Hash64Str(k, 0), len(s.alphas))
min1 := other.alphas[xhash]
min2 := other.alphas[xhash]
switch {
case ok1 && ok2:
e1 := s.k.elts[idx1]
e2 := other.k.elts[idx2]
eMap[k] = Element{
Key: k,
Count: e1.Count + e2.Count,
Error: e1.Error + e2.Error,
}
case ok1:
e1 := s.k.elts[idx1]
eMap[k] = Element{
Key: k,
Count: e1.Count + min2,
Error: e1.Error + min2,
}
case ok2:
e2 := other.k.elts[idx2]
eMap[k] = Element{
Key: k,
Count: e2.Count + min1,
Error: e2.Error + min1,
}
}
}
// sort the elements
elts := make([]Element, 0, len(eMap))
for _, v := range eMap {
elts = append(elts, v)
}
sort.Sort(elementsByCountDescending(elts))
// trim elements
if len(elts) > s.n {
elts = elts[:s.n]
}
// create heap
tk := keys{
m: make(map[string]int),
elts: make([]Element, 0, s.n),
}
for _, e := range elts {
heap.Push(&tk, e)
}
// modify alphas
for i, v := range other.alphas {
s.alphas[i] += v
}
// replace k
s.k = tk
return nil
}
// Keys returns the current estimates for the most frequent elements
func (s *Stream) Keys() []Element {
elts := append([]Element(nil), s.k.elts...)
sort.Sort(elementsByCountDescending(elts))
if len(elts) > s.n {
elts = elts[:s.n]
}
return elts
}
// Estimate returns an estimate for the item x
func (s *Stream) Estimate(x string) Element {
xhash := reduce(metro.Hash64Str(x, 0), len(s.alphas))
// are we tracking this element?
if idx, ok := s.k.m[x]; ok {
e := s.k.elts[idx]
return e
}
count := s.alphas[xhash]
e := Element{
Key: x,
Error: count,
Count: count,
}
return e
}
// EncodeMsgp ...
func (s *Stream) EncodeMsgp(w *msgp.Writer) error {
if err := w.WriteInt(s.n); err != nil {
return err
}
if err := w.WriteArrayHeader(uint32(len(s.alphas))); err != nil {
return err
}
for _, a := range s.alphas {
if err := w.WriteInt(a); err != nil {
return err
}
}
return s.k.EncodeMsgp(w)
}
// DecodeMsgp ...
func (s *Stream) DecodeMsgp(r *msgp.Reader) error {
var (
err error
sz uint32
)
if s.n, err = r.ReadInt(); err != nil {
return err
}
if sz, err = r.ReadArrayHeader(); err != nil {
return err
}
s.alphas = make([]int, sz)
for i := range s.alphas {
if s.alphas[i], err = r.ReadInt(); err != nil {
return err
}
}
return s.k.DecodeMsp(r)
}
// Encode ...
func (s *Stream) Encode(w io.Writer) error {
wrt := msgp.NewWriter(w)
if err := s.EncodeMsgp(wrt); err != nil {
return err
}
return wrt.Flush()
}
// Decode ...
func (s *Stream) Decode(r io.Reader) error {
rdr := msgp.NewReader(r)
return s.DecodeMsgp(rdr)
} | topk.go | 0.849847 | 0.424651 | topk.go | starcoder |
package bytes
import (
"crypto/rand"
"encoding/base64"
"encoding/hex"
"fmt"
)
// BitCount returns the count of bits in the byte slice
func BitCount(bytes []byte) (count int) {
for _, b := range bytes {
count += bitCounts[b]
}
return
}
// EditDistance returns the Hamming distance between the byte slides
func EditDistance(a, b []byte) (distance int) {
return BitCount(Xor(a, b))
}
// Xor returns a byte slice that is the Xor of the two byte slices
func Xor(a, b []byte) []byte {
if len(a) != len(b) {
panic("Xor only works on equal length byte slices")
}
c := make([]byte, len(a))
for i := range a {
c[i] = a[i] ^ b[i]
}
return c
}
// CycledXor returns the Xor where the second byte slice is cycled
func CycledXor(a, b []byte) []byte {
var c = make([]byte, len(a))
for i := range a {
c[i] = a[i] ^ b[i%len(b)]
}
return c
}
// FromBase64 decodes a base 64 encoded string to bytes
func FromBase64(s string) []byte {
data, err := base64.StdEncoding.DecodeString(s)
if err != nil {
panic(err)
}
return data
}
// ToBase64 encodes bytes as base 64 string
func ToBase64(data []byte) string {
return base64.StdEncoding.EncodeToString(data)
}
// FromHex decodes a hex string to bytes
func FromHex(s string) []byte {
data, err := hex.DecodeString(s)
if err != nil {
panic(err)
}
return data
}
// ToHex encodes bytes to a hex string
func ToHex(data []byte) string {
return hex.EncodeToString(data)
}
// CycledSplit splits the bytes into
func CycledSplit(data []byte, n int) [][]byte {
rows := make([][]byte, n)
for i := range rows {
rows[i] = make([]byte, 0, len(data)/n+1)
}
for i, d := range data {
rows[i%n] = append(rows[i%n], d)
}
return rows
}
// Pad adds padding returning a new slice
func Pad(data []byte, padding byte, n int) []byte {
padded := make([]byte, len(data)+n)
for i, c := range data {
padded[i] = c
}
for i := len(data); i < len(padded); i++ {
padded[i] = padding
}
return padded
}
// PadPkcs7 adds PKCS#7 padding
func PadPkcs7(data []byte, blockSize int) []byte {
n := blockSize - len(data)%blockSize
return Pad(data, byte(n), n)
}
// StripPkcs7 strips padding and returns a new slice
func StripPkcs7(data []byte) []byte {
n := data[len(data)-1]
for i := 1; i <= int(n); i++ {
if data[len(data)-i] != n {
panic(fmt.Sprintf("Invalid Pkcs#7 padding: %v", data))
}
}
i := len(data)
for i > 0 && data[i-1] == byte(4) {
i--
}
stripped := make([]byte, len(data)-int(n))
copy(stripped, data[0:len(data)-int(n)])
return stripped
}
// StripByte strips passed byte from the end
func StripByte(data []byte, b byte) []byte {
i := len(data)
for i > 0 && data[i-1] == b {
i--
}
stripped := make([]byte, i)
copy(stripped, data[0:i])
return stripped
}
// Random bytes
func Random(n int) []byte {
bytes := make([]byte, n)
rand.Read(bytes)
return bytes
}
// Join a bunch of byte slices without mutating
func Join(slices ...[]byte) []byte {
var length int
for _, s := range slices {
length += len(s)
}
joined := make([]byte, length)
var i int
for _, s := range slices {
i += copy(joined[i:], s)
}
return joined
}
// Match checks if slices match
func Match(a, b []byte) bool {
if len(a) != len(b) {
return false
}
for i := range a {
if a[i] != b[i] {
return false
}
}
return true
}
// ReplaceByte replace matching bytes
func ReplaceByte(a []byte, replace, with byte) []byte {
replaced := make([]byte, len(a))
for i := range a {
if a[i] == replace {
replaced[i] = with
} else {
replaced[i] = a[i]
}
}
return replaced
} | bytes/bytes.go | 0.732305 | 0.414721 | bytes.go | starcoder |
package expr
import (
"fmt"
"reflect"
)
func isBool(val interface{}) bool {
return val != nil && reflect.TypeOf(val).Kind() == reflect.Bool
}
func toBool(val interface{}) bool {
return reflect.ValueOf(val).Bool()
}
func isText(val interface{}) bool {
return val != nil && reflect.TypeOf(val).Kind() == reflect.String
}
func toText(val interface{}) string {
return reflect.ValueOf(val).String()
}
func equal(left, right interface{}) bool {
if isNumber(left) && canBeNumber(right) {
right, _ := cast(right)
return left == right
} else if canBeNumber(left) && isNumber(right) {
left, _ := cast(left)
return left == right
} else {
return reflect.DeepEqual(left, right)
}
}
func isNumber(val interface{}) bool {
return val != nil && reflect.TypeOf(val).Kind() == reflect.Float64
}
func cast(v interface{}) (float64, error) {
if v != nil {
switch reflect.TypeOf(v).Kind() {
case reflect.Float32, reflect.Float64:
return v.(float64), nil
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return float64(reflect.ValueOf(v).Int()), nil
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
return float64(reflect.ValueOf(v).Uint()), nil // TODO: Check if uint64 fits into float64.
}
}
return 0, fmt.Errorf("can't cast %T to float64", v)
}
func canBeNumber(v interface{}) bool {
if v != nil {
return isNumberType(reflect.TypeOf(v))
}
return false
}
func extract(from interface{}, it interface{}) (interface{}, error) {
if from != nil {
switch reflect.TypeOf(from).Kind() {
case reflect.Array, reflect.Slice, reflect.String:
i, err := cast(it)
if err != nil {
return nil, err
}
value := reflect.ValueOf(from).Index(int(i))
if value.IsValid() && value.CanInterface() {
return value.Interface(), nil
}
case reflect.Map:
value := reflect.ValueOf(from).MapIndex(reflect.ValueOf(it))
if value.IsValid() && value.CanInterface() {
return value.Interface(), nil
}
case reflect.Struct:
value := reflect.ValueOf(from).FieldByName(reflect.ValueOf(it).String())
if value.IsValid() && value.CanInterface() {
return value.Interface(), nil
}
case reflect.Ptr:
value := reflect.ValueOf(from).Elem()
if value.IsValid() && value.CanInterface() {
return extract(value.Interface(), it)
}
}
}
return nil, fmt.Errorf("can't get %q from %T", it, from)
}
func contains(needle interface{}, array interface{}) (bool, error) {
if array != nil {
value := reflect.ValueOf(array)
switch reflect.TypeOf(array).Kind() {
case reflect.Array, reflect.Slice:
for i := 0; i < value.Len(); i++ {
value := value.Index(i)
if value.IsValid() && value.CanInterface() {
if equal(value.Interface(), needle) {
return true, nil
}
}
}
return false, nil
}
return false, fmt.Errorf("operator in not defined on %T", array)
}
return false, nil
}
func count(node Node, array interface{}) (float64, error) {
if array != nil {
value := reflect.ValueOf(array)
switch reflect.TypeOf(array).Kind() {
case reflect.Array, reflect.Slice:
return float64(value.Len()), nil
case reflect.String:
return float64(value.Len()), nil
}
return 0, fmt.Errorf("invalid argument %v (type %T) for len", node, array)
}
return 0, nil
}
func call(name string, fn interface{}, arguments []Node, env interface{}) (interface{}, error) {
in := make([]reflect.Value, 0)
for _, arg := range arguments {
a, err := Run(arg, env)
if err != nil {
return nil, err
}
in = append(in, reflect.ValueOf(a))
}
out := reflect.ValueOf(fn).Call(in)
if len(out) == 0 {
return nil, nil
} else if len(out) > 1 {
return nil, fmt.Errorf("func %q must return only one value", name)
}
if out[0].IsValid() && out[0].CanInterface() {
return out[0].Interface(), nil
}
return nil, nil
} | utils.go | 0.549641 | 0.545346 | utils.go | starcoder |
package httpref
// RegisteredPorts is the list of all known IANA registered ports
var RegisteredPorts = References{
{
Name: "Registered Ports",
IsTitle: true,
Summary: "The range of port numbers from 1024 to 49151 (2^10 to 2^14 + 2^15 − 1)",
Description: `The range of port numbers from 1024 to 49151 (210 to 214 + 215 − 1) are the registered ports. They are assigned by IANA for specific service upon application by a requesting entity.[1] On most systems, registered ports can be used without superuser privileges.
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1024",
Description: `
Reserved
IANA Status - Official
TCP - Reserved
UDP - Reserved
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1027",
Description: `
Reserved
IANA Status - Official
TCP - Reserved
UDP - Unspecified
"Native IPv6 behind IPv4-to-IPv4 NAT Customer Premises Equipment (6a44)"
IANA Status - Official
TCP - Unspecified
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1028",
Description: `
Deprecated
IANA Status - Official
TCP - Unspecified
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1029",
Description: `
"Microsoft DCOM (https://en.wikipedia.org/wiki/Distributed_Component_Object_Model) services"
IANA Status - Unofficial
TCP - Unspecified
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1058",
Description: `
"nim, IBM (https://en.wikipedia.org/wiki/IBM) AIX (https://en.wikipedia.org/wiki/IBM_AIX) Network Installation Manager (https://en.wikipedia.org/wiki/Network_Installation_Manager) (NIM)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1059",
Description: `
nimreg, IBM AIX Network Installation Manager (NIM)
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1080",
Description: `
"SOCKS (https://en.wikipedia.org/wiki/SOCKS) proxy"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1085",
Description: `
"WebObjects (https://en.wikipedia.org/wiki/WebObjects)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1098",
Description: `
"rmiactivation, Java remote method invocation (https://en.wikipedia.org/wiki/Java_remote_method_invocation) (RMI) activation"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1099",
Description: `
rmiregistry, Java remote method invocation (RMI) registry
IANA Status - Official
TCP - Yes
UDP - Assigned
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1109",
Description: `
Reserved – IANA
IANA Status - Official
TCP - Unspecified
UDP - Unspecified
"Kerberos (https://en.wikipedia.org/wiki/Kerberos_(protocol)) Post Office Protocol (KPOP (https://en.wikipedia.org/wiki/Kerberized_Post_Office_Protocol))"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1113",
Description: `
"Licklider Transmission Protocol (https://en.wikipedia.org/wiki/Licklider_Transmission_Protocol) (LTP) delay tolerant networking protocol"
IANA Status - Official
TCP - "Assigned"
UDP - "Yes"
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1119",
Description: `
"Battle.net (https://en.wikipedia.org/wiki/Battle.net) chat/game protocol, used by Blizzard (https://en.wikipedia.org/wiki/Blizzard_Entertainment)'s games"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1167",
Description: `
"Cisco IP SLA (https://en.wikipedia.org/wiki/IP_SLA) (Service Assurance Agent)"
IANA Status - Official
TCP - Yes, and SCTP
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1194",
Description: `
"OpenVPN (https://en.wikipedia.org/wiki/OpenVPN#Networking)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1198",
Description: `
"The cajo project (https://en.wikipedia.org/wiki/Cajo_project) Free dynamic transparent distributed computing in Java"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1214",
Description: `
"Kazaa (https://en.wikipedia.org/wiki/Kazaa)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1218",
Description: `
William POWER
IANA Status - Official
TCP - Yes
UDP - No
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1220",
Description: `
"QuickTime Streaming Server (https://en.wikipedia.org/wiki/QuickTime_Streaming_Server) administration"
IANA Status - Official
TCP - Yes
UDP - Assigned
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1234",
Description: `
"Infoseek (https://en.wikipedia.org/wiki/Infoseek) search agent"
IANA Status - Official
TCP - Yes
UDP - Yes
"VLC media player (https://en.wikipedia.org/wiki/VLC_media_player) default port for UDP/RTP stream"
IANA Status - Unofficial
TCP - Unspecified
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1241",
Description: `
"Nessus (https://en.wikipedia.org/wiki/Nessus_(software)) Security Scanner"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1270",
Description: `
"Microsoft System Center Operations Manager (https://en.wikipedia.org/wiki/System_Center_Operations_Manager) (SCOM) (formerly Microsoft Operations Manager (MOM)) agent"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1293",
Description: `
"Internet Protocol Security (IPSec (https://en.wikipedia.org/wiki/IPSec))"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1311",
Description: `
Windows RxMon.exe
IANA Status - Official
TCP - Yes
UDP - Yes
"Dell OpenManage (https://en.wikipedia.org/wiki/OpenManage) HTTPS"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1314",
Description: `
"Festival Speech Synthesis System (https://en.wikipedia.org/wiki/Festival_Speech_Synthesis_System) server"
IANA Status - Unofficial
TCP - ?
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1337",
Description: `
"neo4j-shell (https://en.wikipedia.org/wiki/Neo4j)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"Strapi (/w/index.php?title=Strapi&action=edit&redlink=1)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"Sails.js (https://en.wikipedia.org/wiki/Sails.js) default port"
IANA Status - Unofficial
TCP - Yes
UDP - ?
"WASTE (https://en.wikipedia.org/wiki/WASTE) Encrypted File Sharing Program"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1341",
Description: `
"Qubes (Manufacturing Execution System (https://en.wikipedia.org/wiki/Manufacturing_Execution_System))"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1344",
Description: `
"Internet Content Adaptation Protocol (https://en.wikipedia.org/wiki/Internet_Content_Adaptation_Protocol)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1352",
Description: `
"IBM Lotus Notes (https://en.wikipedia.org/wiki/Lotus_Notes)/Domino (https://en.wikipedia.org/wiki/IBM_Lotus_Domino) (RPC) (https://en.wikipedia.org/wiki/Remote_procedure_call) protocol"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1360",
Description: `
"Mimer SQL (https://en.wikipedia.org/wiki/Mimer_SQL)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1414",
Description: `
"IBM (https://en.wikipedia.org/wiki/IBM) WebSphere MQ (https://en.wikipedia.org/wiki/WebSphere_MQ) (formerly known as MQSeries (https://en.wikipedia.org/wiki/MQSeries))"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1417",
Description: `
"Timbuktu (https://en.wikipedia.org/wiki/Timbuktu_(software)) Service 1 Port"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1418",
Description: `
Timbuktu Service 2 Port
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1419",
Description: `
Timbuktu Service 3 Port
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1420",
Description: `
Timbuktu Service 4 Port
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1431",
Description: `
"Reverse Gossip Transport Protocol (/w/index.php?title=Reverse_Gossip_Transport_Protocol&action=edit&redlink=1) (RGTP), used to access a General-purpose Reverse-Ordered Gossip Gathering System (GROGGS) bulletin board (https://en.wikipedia.org/wiki/Bulletin_board_system), such as that implemented on the Cambridge University (https://en.wikipedia.org/wiki/University_of_Cambridge)'s Phoenix system (https://en.wikipedia.org/wiki/Phoenix_(computer))"
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1433",
Description: `
"Microsoft SQL Server (https://en.wikipedia.org/wiki/Microsoft_SQL_Server) database management system (https://en.wikipedia.org/wiki/Database_management_system) (MSSQL) server"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1434",
Description: `
Microsoft SQL Server database management system (MSSQL) monitor
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1481",
Description: `
AIRS data interchange.
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1492",
Description: `
"Sid Meier's CivNet (https://en.wikipedia.org/wiki/Sid_Meier%27s_CivNet), a multiplayer remake of the original Sid Meier's Civilization game"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1494",
Description: `
"Citrix Independent Computing Architecture (https://en.wikipedia.org/wiki/Independent_Computing_Architecture) (ICA)"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1500",
Description: `
"IBM Tivoli Storage Manager (https://en.wikipedia.org/wiki/IBM_Tivoli_Storage_Manager) server"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1501",
Description: `
"IBM Tivoli Storage Manager client scheduler"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1503",
Description: `
"Windows Live Messenger (https://en.wikipedia.org/wiki/Windows_Live_Messenger) (Whiteboard and Application Sharing)"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1512",
Description: `
"Microsoft's Windows Internet Name Service (https://en.wikipedia.org/wiki/Windows_Internet_Name_Service) (WINS)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1513",
Description: `
"Garena (https://en.wikipedia.org/wiki/Garena) game client"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1521",
Description: `
"nCUBE (https://en.wikipedia.org/wiki/NCUBE) License Manager"
IANA Status - Official
TCP - Yes
UDP - Yes
"Oracle database (https://en.wikipedia.org/wiki/Oracle_database) default listener, in future releases official port 2483 (TCP/IP) and 2484 (TCP/IP with SSL)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1524",
Description: `
"ingreslock, ingres (https://en.wikipedia.org/wiki/Ingres_(database))"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1527",
Description: `
"Oracle Net Services (https://en.wikipedia.org/wiki/Oracle_Net_Services), formerly known as SQL*Net"
IANA Status - Official
TCP - Yes
UDP - Yes
"Apache Derby Network Server (https://en.wikipedia.org/wiki/Apache_Derby#Derby_Network_Server)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1533",
Description: `
"IBM Sametime (https://en.wikipedia.org/wiki/IBM_Sametime) Virtual Places Chat"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1534",
Description: `
"Eclipse Target Communication Framework "
IANA Status - Unofficial
TCP - No
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1540",
Description: `
"1C:Enterprise (https://en.wikipedia.org/wiki/1C:Enterprise) server agent (ragent)"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1541",
Description: `
"1C:Enterprise master cluster manager (rmngr)"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1542",
Description: `
"1C:Enterprise configuration repository server"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1545",
Description: `
"1C:Enterprise cluster administration server (RAS)"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1547",
Description: `
"Laplink (https://en.wikipedia.org/wiki/Laplink)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1550",
Description: `
"1C:Enterprise debug server"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
"Gadu-Gadu (https://en.wikipedia.org/wiki/Gadu-Gadu) (direct client-to-client)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1560-1590",
Description: `
"1C:Enterprise cluster working processes"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1581",
Description: `
"MIL STD 2045-47001 VMF (https://en.wikipedia.org/wiki/Combat-net_radio)"
IANA Status - Official
TCP - Yes
UDP - Yes
"IBM Tivoli Storage Manager (https://en.wikipedia.org/wiki/IBM_Tivoli_Storage_Manager) web client"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1582-1583",
Description: `
"IBM Tivoli Storage Manager server web interface"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1583",
Description: `
"Pervasive PSQL (https://en.wikipedia.org/wiki/Pervasive_PSQL)"
IANA Status - Unofficial
TCP - ?
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1589",
Description: `
"Cisco VLAN Query Protocol (VQP (https://en.wikipedia.org/wiki/VQP))"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1604",
Description: `
"DarkComet (https://en.wikipedia.org/wiki/DarkComet) remote administration tool (RAT)"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1626",
Description: `
"iSketch (https://en.wikipedia.org/wiki/ISketch)"
IANA Status - Unofficial
TCP - Yes
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1627",
Description: `
"iSketch"
IANA Status - Unofficial
TCP - Yes
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1628",
Description: `
"LonTalk (https://en.wikipedia.org/wiki/LonTalk) normal"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1629",
Description: `
LonTalk urgent
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1645",
Description: `
"Early deployment of RADIUS (https://en.wikipedia.org/wiki/RADIUS) before RFC standardization was done using UDP port number 1645. Enabled for compatibility reasons by default on Cisco (https://en.wikipedia.org/wiki/Cisco) and Juniper Networks (https://en.wikipedia.org/wiki/Juniper_Networks) RADIUS servers. Official port is 1812. TCP port 1645 must not be used."
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1646",
Description: `
"Old radacct port, RADIUS accounting protocol. Enabled for compatibility reasons by default on Cisco (https://en.wikipedia.org/wiki/Cisco) and Juniper Networks (https://en.wikipedia.org/wiki/Juniper_Networks) RADIUS servers. Official port is 1813. TCP port 1646 must not be used."
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1666",
Description: `
"Perforce (https://en.wikipedia.org/wiki/Perforce)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1677",
Description: `
"Novell GroupWise (https://en.wikipedia.org/wiki/Novell_GroupWise) clients in client/server access mode"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1688",
Description: `
"Microsoft Key Management Service (https://en.wikipedia.org/wiki/Key_Management_Service) (KMS) for Windows Activation"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1701",
Description: `
"Layer 2 Forwarding Protocol (https://en.wikipedia.org/wiki/Layer_2_Forwarding_Protocol) (L2F)"
IANA Status - Official
TCP - Yes
UDP - Yes
"Layer 2 Tunneling Protocol (https://en.wikipedia.org/wiki/Layer_2_Tunneling_Protocol) (L2TP)"
IANA Status - Official
TCP - Assigned
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1707",
Description: `
"Windward Studios (https://en.wikipedia.org/wiki/Windward_Studios) games (vdmplay)"
IANA Status - Official
TCP - Yes
UDP - Yes
"L2TP/IPsec, for establish an initial connection"
IANA Status - Unofficial
TCP - Unspecified
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1716",
Description: `
"America's Army (https://en.wikipedia.org/wiki/America%27s_Army), a massively multiplayer online game (https://en.wikipedia.org/wiki/Massively_multiplayer_online_game) (MMO)"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1719",
Description: `
"H.323 (https://en.wikipedia.org/wiki/H.323) registration and alternate communication"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1720",
Description: `
"H.323 (https://en.wikipedia.org/wiki/H.323) call signaling"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1723",
Description: `
"Point-to-Point Tunneling Protocol (https://en.wikipedia.org/wiki/Point-to-Point_Tunneling_Protocol) (PPTP)"
IANA Status - Official
TCP - Yes
UDP - Assigned
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1755",
Description: `
"Microsoft Media Services (https://en.wikipedia.org/wiki/Microsoft_Media_Services) (MMS, ms-streaming)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1761",
Description: `
"Novell ZENworks (https://en.wikipedia.org/wiki/Novell_ZENworks)"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1783",
Description: `
"Decomissioned [sic (https://en.wikipedia.org/wiki/Sic)] Port 04/14/00, ms"
IANA Status - Official
TCP - Unspecified
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1801",
Description: `
"Microsoft Message Queuing (https://en.wikipedia.org/wiki/Microsoft_Message_Queuing)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1812",
Description: `
"RADIUS (https://en.wikipedia.org/wiki/RADIUS) authentication protocol, radius"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1813",
Description: `
"RADIUS (https://en.wikipedia.org/wiki/RADIUS) accounting protocol, radius-acct"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1863",
Description: `
"Microsoft Notification Protocol (https://en.wikipedia.org/wiki/Microsoft_Notification_Protocol) (MSNP), used by the Microsoft Messenger service (https://en.wikipedia.org/wiki/Microsoft_Messenger_service) and a number of instant messaging Messenger clients (https://en.wikipedia.org/wiki/Microsoft_Messenger_service#Official_clients)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1880",
Description: `
"Node-RED (https://en.wikipedia.org/wiki/Node-RED)"
IANA Status - Unofficial
TCP - ?
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1883",
Description: `
"MQTT (https://en.wikipedia.org/wiki/MQTT) (formerly MQ Telemetry Transport)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1900",
Description: `
"Simple Service Discovery Protocol (https://en.wikipedia.org/wiki/Simple_Service_Discovery_Protocol) (SSDP), discovery of UPnP (https://en.wikipedia.org/wiki/Universal_Plug_and_Play) devices"
IANA Status - Official
TCP - Assigned
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1935",
Description: `
"Macromedia Flash (https://en.wikipedia.org/wiki/Macromedia_Flash) Communications Server MX (https://en.wikipedia.org/wiki/Macromedia_Studio_MX), the precursor to Adobe Flash Media Server (https://en.wikipedia.org/wiki/Adobe_Flash_Media_Server) before Macromedia (https://en.wikipedia.org/wiki/Macromedia)'s acquisition by Adobe (https://en.wikipedia.org/wiki/Adobe_Inc) on December 3, 2005"
IANA Status - Official
TCP - Yes
UDP - Yes
"Real Time Messaging Protocol (https://en.wikipedia.org/wiki/Real_Time_Messaging_Protocol) (RTMP), primarily used in Adobe Flash (https://en.wikipedia.org/wiki/Adobe_Flash)"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1967",
Description: `
"Cisco IOS IP Service Level Agreements (IP SLAs (https://en.wikipedia.org/wiki/IP_SLA)) Control Protocol"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1970",
Description: `
"Netop Remote Control (https://en.wikipedia.org/wiki/Netop_Remote_Control)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1972",
Description: `
"InterSystems Caché (https://en.wikipedia.org/wiki/InterSystems_Cach%C3%A9)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1984",
Description: `
"Big Brother (https://en.wikipedia.org/wiki/Big_Brother_(software))"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1985",
Description: `
"Cisco Hot Standby Router Protocol (https://en.wikipedia.org/wiki/Hot_Standby_Router_Protocol) (HSRP)"
IANA Status - Official
TCP - Assigned
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "1998",
Description: `
"Cisco (https://en.wikipedia.org/wiki/Cisco) X.25 over TCP (XOT (https://en.wikipedia.org/wiki/XOT)) service"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2000",
Description: `
"Cisco Skinny Client Control Protocol (https://en.wikipedia.org/wiki/Skinny_Client_Control_Protocol) (SCCP)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2010",
Description: `
"Artemis: Spaceship Bridge Simulator (https://en.wikipedia.org/wiki/Artemis:_Spaceship_Bridge_Simulator)"
IANA Status - Unofficial
TCP - ?
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2033",
Description: `
"Civilization IV (https://en.wikipedia.org/wiki/Civilization_IV) multiplayer"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2049",
Description: `
"Network File System (https://en.wikipedia.org/wiki/Network_File_System) (NFS)"
IANA Status - Official
TCP - Yes, and SCTP
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2056",
Description: `
"Civilization IV multiplayer"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2080",
Description: `
"Autodesk (https://en.wikipedia.org/wiki/Autodesk) NLM (FLEXlm (https://en.wikipedia.org/wiki/FLEXlm))"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2082",
Description: `
"cPanel (https://en.wikipedia.org/wiki/CPanel) default"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2083",
Description: `
"Secure RADIUS (https://en.wikipedia.org/wiki/RADIUS) Service (radsec)"
IANA Status - Official
TCP - Yes
UDP - Yes
"cPanel default SSL (https://en.wikipedia.org/wiki/Secure_Sockets_Layer)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2086",
Description: `
"GNUnet (https://en.wikipedia.org/wiki/GNUnet)"
IANA Status - Official
TCP - Yes
UDP - Yes
"WebHost Manager (https://en.wikipedia.org/wiki/WHM) default"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2087",
Description: `
"WebHost Manager default SSL (https://en.wikipedia.org/wiki/Secure_Sockets_Layer)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2095",
Description: `
"cPanel default web mail"
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2096",
Description: `
"cPanel default SSL (https://en.wikipedia.org/wiki/Secure_Sockets_Layer) web mail"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2100",
Description: `
"Warzone 2100 (https://en.wikipedia.org/wiki/Warzone_2100) multiplayer"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2101",
Description: `
"Networked Transport of RTCM via Internet Protocol (https://en.wikipedia.org/wiki/Networked_Transport_of_RTCM_via_Internet_Protocol) (NTRIP)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2102",
Description: `
"Zephyr Notification Service (https://en.wikipedia.org/wiki/Zephyr_(protocol)) server"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2103",
Description: `
Zephyr Notification Service serv-hm connection
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2104",
Description: `
Zephyr Notification Service hostmanager
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2123",
Description: `
"GTP (https://en.wikipedia.org/wiki/GPRS_Tunnelling_Protocol) control messages (GTP-C)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2142",
Description: `
"TDMoIP (https://en.wikipedia.org/wiki/TDMoIP) (TDM over IP)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2152",
Description: `
"GTP (https://en.wikipedia.org/wiki/GPRS_Tunnelling_Protocol) user data messages (GTP-U)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2159",
Description: `
"GDB remote debug port (https://en.wikipedia.org/wiki/Gdbserver)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2181",
Description: `
"EForward (https://en.wikipedia.org/wiki/EForward)-document transport system"
IANA Status - Official
TCP - Yes
UDP - Yes
"Apache ZooKeeper (https://en.wikipedia.org/wiki/Apache_ZooKeeper) default client port"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2195",
Description: `
"Apple Push Notification Service (https://en.wikipedia.org/wiki/Apple_Push_Notification_Service)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2196",
Description: `
"Apple Push Notification Service, feedback service"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2210",
Description: `
"NOAAPORT (https://en.wikipedia.org/wiki/National_Weather_Service) Broadcast Network"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2211",
Description: `
"EMWIN (https://en.wikipedia.org/wiki/EMWIN)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2221",
Description: `
"ESET (https://en.wikipedia.org/wiki/ESET) anti-virus updates"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2222",
Description: `
"EtherNet/IP (https://en.wikipedia.org/wiki/EtherNet/IP) implicit messaging for IO data"
IANA Status - Official
TCP - Yes
UDP - Yes
"DirectAdmin (https://en.wikipedia.org/wiki/DirectAdmin) Access"
IANA Status - Unofficial
TCP - ?
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2222-2226",
Description: `
"ESET Remote administrator"
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2240",
Description: `
"General Dynamics (https://en.wikipedia.org/wiki/General_Dynamics) Remote Encryptor Configuration Information Protocol (RECIPe)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2261",
Description: `
"CoMotion (https://en.wikipedia.org/wiki/CoMotion) master"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2262",
Description: `
CoMotion backup
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2302",
Description: `
"ArmA (https://en.wikipedia.org/wiki/ArmA) multiplayer"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
"Halo: Combat Evolved (https://en.wikipedia.org/wiki/Halo:_Combat_Evolved) multiplayer host"
IANA Status - Unofficial
TCP - Unspecified
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2303",
Description: `
"ArmA multiplayer (default port for game +1)"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
"Halo: Combat Evolved multiplayer listener"
IANA Status - Unofficial
TCP - Unspecified
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2305",
Description: `
"ArmA multiplayer (default port for game +3)"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2351",
Description: `
"AIM (https://en.wikipedia.org/wiki/AOL_Instant_Messenger) game LAN network port"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2368",
Description: `
"Ghost (blogging platform) (https://en.wikipedia.org/wiki/Ghost_(blogging_platform))"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2369",
Description: `
"Default for BMC Control-M/Server (https://en.wikipedia.org/wiki/BMC_Control-M) Configuration Agent"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2370",
Description: `
Default for BMC Control-M/Server, to allow the Control-M/Enterprise Manager to connect to the Control-M/Server
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2372",
Description: `
"Default for K9 Web Protection (https://en.wikipedia.org/wiki/K9_Web_Protection)/parental controls, content filtering agent"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2375",
Description: `
"Docker (https://en.wikipedia.org/wiki/Docker_(software)) REST API (plain)"
IANA Status - Official
TCP - Yes
UDP - Reserved
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2376",
Description: `
Docker REST API (SSL)
IANA Status - Official
TCP - Yes
UDP - Reserved
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2377",
Description: `
"Docker Swarm cluster management communications"
IANA Status - Official
TCP - Yes
UDP - Reserved
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2379",
Description: `
"CoreOS etcd (https://en.wikipedia.org/wiki/Etcd) client communication"
IANA Status - Official
TCP - Yes
UDP - Reserved
"KGS Go Server (https://en.wikipedia.org/wiki/KGS_Go_Server)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2380",
Description: `
CoreOS etcd server communication
IANA Status - Official
TCP - Yes
UDP - Reserved
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2389",
Description: `
OpenView Session Mgr
IANA Status - Official
TCP - Assigned
UDP - Assigned
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2399",
Description: `
"FileMaker (https://en.wikipedia.org/wiki/FileMaker) Data Access Layer (ODBC/JDBC)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2401",
Description: `
"CVS (https://en.wikipedia.org/wiki/Concurrent_Versions_System) version control system password-based server"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2404",
Description: `
"IEC 60870-5-104 (https://en.wikipedia.org/wiki/IEC_60870-5-104), used to send electric power telecontrol messages between two systems via directly connected data circuits (/w/index.php?title=Data_circuit&action=edit&redlink=1)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2424",
Description: `
"OrientDB (https://en.wikipedia.org/wiki/OrientDB) database listening for binary client connections"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2427",
Description: `
"Media Gateway Control Protocol (https://en.wikipedia.org/wiki/Media_Gateway_Control_Protocol) (MGCP) media gateway"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2447",
Description: `
"ovwdb—OpenView (https://en.wikipedia.org/wiki/OpenView) Network Node Manager (https://en.wikipedia.org/wiki/Network_Node_Manager) (NNM) daemon"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2459",
Description: `
"XRPL (https://en.wikipedia.org/wiki/Xrp)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2480",
Description: `
"OrientDB (https://en.wikipedia.org/wiki/OrientDB) database listening for HTTP client connections"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2483",
Description: `
"Oracle database (https://en.wikipedia.org/wiki/Oracle_database) listening for insecure client connections to the listener, replaces port 1521"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2484",
Description: `
"Oracle database listening for SSL (https://en.wikipedia.org/wiki/Secure_Sockets_Layer) client connections to the listener"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2500",
Description: `
"NetFS communication"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2501",
Description: `
NetFS probe
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2535",
Description: `
"Multicast Address Dynamic Client Allocation Protocol (https://en.wikipedia.org/wiki/Multicast_Address_Dynamic_Client_Allocation_Protocol) (MADCAP). All standard messages are UDP datagrams."
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2541",
Description: `
"LonTalk (https://en.wikipedia.org/wiki/LonTalk)/IP"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2546-2548",
Description: `
"EVault (https://en.wikipedia.org/wiki/EVault) data protection services"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2593",
Description: `
"Ultima Online (https://en.wikipedia.org/wiki/Ultima_Online) servers"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2598",
Description: `
"Citrix Independent Computing Architecture (https://en.wikipedia.org/wiki/Independent_Computing_Architecture) (ICA) with Session Reliability; port 1494 without session reliability"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2599",
Description: `
"Ultima Online servers"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2628",
Description: `
"DICT (https://en.wikipedia.org/wiki/DICT) "
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2638",
Description: `
"SQL Anywhere (https://en.wikipedia.org/wiki/SQL_Anywhere) database server"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2710",
Description: `
"XBT Tracker (https://en.wikipedia.org/wiki/XBT_Tracker). UDP tracker extension is considered experimental."
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2727",
Description: `
"Media Gateway Control Protocol (https://en.wikipedia.org/wiki/Media_Gateway_Control_Protocol) (MGCP) media gateway controller (call agent)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2775",
Description: `
"Short Message Peer-to-Peer (https://en.wikipedia.org/wiki/Short_Message_Peer-to-Peer) (SMPP)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2809",
Description: `
"corbaloc:iiop URL, per the CORBA (https://en.wikipedia.org/wiki/CORBA) 3.0.3 specification"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2811",
Description: `
"gsi ftp, per the GridFTP (https://en.wikipedia.org/wiki/GridFTP) specification"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2827",
Description: `
"I2P (https://en.wikipedia.org/wiki/I2P) BOB Bridge"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2944",
Description: `
"Megaco (https://en.wikipedia.org/wiki/Megaco) text H.248"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2945",
Description: `
Megaco binary (ASN.1) H.248
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2947",
Description: `
"gpsd (https://en.wikipedia.org/wiki/Gpsd), GPS daemon"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2948",
Description: `
"WAP (https://en.wikipedia.org/wiki/Wireless_Application_Protocol) push Multimedia Messaging Service (https://en.wikipedia.org/wiki/Multimedia_Messaging_Service) (MMS)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2949",
Description: `
WAP push secure (MMS)
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "2967",
Description: `
"Symantec System Center (https://en.wikipedia.org/wiki/Symantec_AntiVirus) agent (SSC-AGENT)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3000",
Description: `
"Cloud9 IDE (https://en.wikipedia.org/wiki/Cloud9_IDE) server"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"Ruby on Rails (https://en.wikipedia.org/wiki/Ruby_on_Rails) development default"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"Meteor (https://en.wikipedia.org/wiki/Meteor_(web_framework)) development default‹See TfM› (https://en.wikipedia.org/wiki/Wikipedia:Templates_for_discussion/Log/2020_August_1#Template:Failed_verification)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"Resilio Sync (https://en.wikipedia.org/wiki/Resilio_Sync), spun from BitTorrent Sync."
IANA Status - Unofficial
TCP - Yes
UDP - Yes
"Distributed Interactive Simulation (https://en.wikipedia.org/wiki/Distributed_Interactive_Simulation) (DIS)"
IANA Status - Unofficial
TCP - Unspecified
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3004",
Description: `
"iSync (https://en.wikipedia.org/wiki/ISync)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3020",
Description: `
"Common Internet File System (https://en.wikipedia.org/wiki/Common_Internet_File_System) (CIFS). See also port 445 for Server Message Block (https://en.wikipedia.org/wiki/Server_Message_Block) (SMB), a dialect of CIFS."
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3050",
Description: `
"gds-db (Interbase (https://en.wikipedia.org/wiki/Interbase)/Firebird (https://en.wikipedia.org/wiki/Firebird_(database_server)) databases)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3052",
Description: `
"APC (https://en.wikipedia.org/wiki/APC_by_Schneider_Electric) PowerChute Network (https://en.wikipedia.org/wiki/PowerChute)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3074",
Description: `
"Xbox LIVE and Games for Windows – Live (https://en.wikipedia.org/wiki/Games_for_Windows_%E2%80%93_Live)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3101",
Description: `
"BlackBerry Enterprise Server (https://en.wikipedia.org/wiki/BlackBerry_Enterprise_Server) communication protocol"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3128",
Description: `
"Squid (https://en.wikipedia.org/wiki/Squid_(software)) caching web proxy"
IANA Status - Unofficial
TCP - Yes
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3225",
Description: `
"Fibre Channel over IP (https://en.wikipedia.org/wiki/Fibre_Channel_over_IP) (FCIP)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3233",
Description: `
"WhiskerControl (https://en.wikipedia.org/wiki/WhiskerControl) research control protocol"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3260",
Description: `
"iSCSI (https://en.wikipedia.org/wiki/ISCSI)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3268",
Description: `
"msft-gc, Microsoft Global Catalog (LDAP (https://en.wikipedia.org/wiki/LDAP) service which contains data from Active Directory (https://en.wikipedia.org/wiki/Active_Directory) forests)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3269",
Description: `
"msft-gc-ssl, Microsoft Global Catalog over SSL (https://en.wikipedia.org/wiki/Secure_Sockets_Layer) (similar to port 3268, LDAP (https://en.wikipedia.org/wiki/LDAP) over SSL (https://en.wikipedia.org/wiki/Secure_Sockets_Layer))"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3283",
Description: `
"Net Assistant, a predecessor to Apple Remote Desktop"
IANA Status - Official
TCP - Yes
UDP - Yes
"Apple Remote Desktop (https://en.wikipedia.org/wiki/Apple_Remote_Desktop) 2.0 or later"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3290",
Description: `
"Virtual Air Traffic Simulation (https://en.wikipedia.org/wiki/VATSIM) (VATSIM) network voice communication"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3305",
Description: `
"Odette File Transfer Protocol (https://en.wikipedia.org/wiki/OFTP) (OFTP)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3306",
Description: `
"MySQL (https://en.wikipedia.org/wiki/MySQL) database system"
IANA Status - Official
TCP - Yes
UDP - Assigned
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3323",
Description: `
"DECE (https://en.wikipedia.org/wiki/DECE) GEODI Server"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3332",
Description: `
Thundercloud DataPath Overlay Control
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3333",
Description: `
"Eggdrop (https://en.wikipedia.org/wiki/Eggdrop), an IRC bot default port"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"Network Caller ID (https://en.wikipedia.org/wiki/Network_Caller_ID) server"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"CruiseControl.rb (https://en.wikipedia.org/wiki/CruiseControl.rb)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3351",
Description: `
"Pervasive PSQL (https://en.wikipedia.org/wiki/Pervasive_PSQL)"
IANA Status - Unofficial
TCP - ?
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3386",
Description: `
"GTP' (https://en.wikipedia.org/wiki/GTP%27) 3GPP (https://en.wikipedia.org/wiki/3GPP) GSM (https://en.wikipedia.org/wiki/GSM)/UMTS (https://en.wikipedia.org/wiki/UMTS) CDR (https://en.wikipedia.org/wiki/Call_detail_record) logging protocol"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3389",
Description: `
"Microsoft Terminal Server (RDP (https://en.wikipedia.org/wiki/Remote_Desktop_Protocol)) officially registered as Windows Based Terminal (WBT)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3396",
Description: `
"Novell (https://en.wikipedia.org/wiki/Novell) NDPS Printer Agent"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3412",
Description: `
xmlBlaster
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3423",
Description: `
Xware xTrm Communication Protocol
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3424",
Description: `
Xware xTrm Communication Protocol over SSL
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3455",
Description: `
"Resource Reservation Protocol (https://en.wikipedia.org/wiki/Resource_Reservation_Protocol) (RSVP)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3478",
Description: `
"STUN (https://en.wikipedia.org/wiki/STUN), a protocol for NAT traversal"
IANA Status - Official
TCP - Yes
UDP - Yes
"TURN (https://en.wikipedia.org/wiki/Traversal_Using_Relay_NAT), a protocol for NAT traversal (extension to STUN)"
IANA Status - Official
TCP - Yes
UDP - Yes
"STUN Behavior Discovery. See also port 5349."
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3479",
Description: `
"PlayStation Network (https://en.wikipedia.org/wiki/PlayStation_Network)"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3480",
Description: `
"PlayStation Network"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3483",
Description: `
"Slim Devices (https://en.wikipedia.org/wiki/Slim_Devices) discovery protocol"
IANA Status - Official
TCP - Unspecified
UDP - Yes
"Slim Devices (https://en.wikipedia.org/wiki/Slim_Devices) SlimProto protocol"
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3493",
Description: `
"Network UPS Tools (https://en.wikipedia.org/wiki/Network_UPS_Tools) (NUT)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3516",
Description: `
Smartcard Port
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3527",
Description: `
"Microsoft Message Queuing (https://en.wikipedia.org/wiki/Microsoft_Message_Queuing)"
IANA Status - Official
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3535",
Description: `
"SMTP (https://en.wikipedia.org/wiki/SMTP) alternate"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3544",
Description: `
"Teredo tunneling (https://en.wikipedia.org/wiki/Teredo_tunneling)"
IANA Status - Official
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3632",
Description: `
"Distcc (https://en.wikipedia.org/wiki/Distcc), distributed compiler"
IANA Status - Official
TCP - Yes
UDP - Assigned
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3645",
Description: `
"Cyc (https://en.wikipedia.org/wiki/Cyc)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3659",
Description: `
"Apple SASL (https://en.wikipedia.org/wiki/Simple_Authentication_and_Security_Layer), used by Mac OS X Server (https://en.wikipedia.org/wiki/Mac_OS_X_Server) Password Server"
IANA Status - Official
TCP - Yes
UDP - Yes
Battlefield 4
IANA Status - Unofficial
TCP - Unspecified
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3667",
Description: `
Information Exchange
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3689",
Description: `
"Digital Audio Access Protocol (https://en.wikipedia.org/wiki/Digital_Audio_Access_Protocol) (DAAP), used by Apple's (https://en.wikipedia.org/wiki/Apple_Inc.) iTunes (https://en.wikipedia.org/wiki/ITunes) and AirPlay (https://en.wikipedia.org/wiki/AirPlay)"
IANA Status - Official
TCP - Yes
UDP - Assigned
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3690",
Description: `
"Subversion (SVN) (https://en.wikipedia.org/wiki/Subversion_(software)) version control system"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3702",
Description: `
"Web Services Dynamic Discovery (https://en.wikipedia.org/wiki/Web_Services_Dynamic_Discovery) (WS-Discovery), used by various components of Windows Vista (https://en.wikipedia.org/wiki/Windows_Vista) and later"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3724",
Description: `
"Some Blizzard (https://en.wikipedia.org/wiki/Blizzard_Entertainment) games"
IANA Status - Official
TCP - Yes
UDP - Yes
"Club Penguin (https://en.wikipedia.org/wiki/Club_Penguin) Disney online game for kids"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3725",
Description: `
Netia NA-ER Port
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3749",
Description: `
"CimTrak (https://www.cimcor.com/cimtrak/) registered port"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3768",
Description: `
RBLcheckd server daemon
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3784",
Description: `
"Bidirectional Forwarding Detection (BFD)for IPv4 and IPv6 (Single Hop) (RFC 5881 (https://tools.ietf.org/html/rfc5881))"
IANA Status - Official
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3785",
Description: `
"VoIP program used by Ventrilo (https://en.wikipedia.org/wiki/Ventrilo)"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3799",
Description: `
"RADIUS (https://en.wikipedia.org/wiki/RADIUS) change of authorization"
IANA Status - Official
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3804",
Description: `
"Harman Professional HiQnet (/w/index.php?title=HiQnet&action=edit&redlink=1) protocol"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3825",
Description: `
"RedSeal Networks client/server connection"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3826",
Description: `
WarMUX game server
IANA Status - Official
TCP - Yes
UDP - Yes
"RedSeal Networks client/server connection"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3835",
Description: `
"RedSeal Networks client/server connection"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3830",
Description: `
System Management Agent, developed and used by Cerner to monitor and manage solutions
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3856",
Description: `
ERP Server Application used by F10 Software
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3880",
Description: `
IGRS
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3868",
Description: `
"Diameter (https://en.wikipedia.org/wiki/Diameter_(protocol) ) base protocol (RFC 3588 (https://tools.ietf.org/html/rfc3588))"
IANA Status - Official
TCP - Yes, and SCTP
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3872",
Description: `
"Oracle Enterprise Manager (https://en.wikipedia.org/wiki/Oracle_Enterprise_Manager) Remote Agent"
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3900",
Description: `
"udt_os, IBM UniData (https://en.wikipedia.org/wiki/IBM_U2) UDT OS"
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3960",
Description: `
"Warframe (https://en.wikipedia.org/wiki/Warframe) online interaction"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3962",
Description: `
"Warframe online interaction"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3978",
Description: `
"OpenTTD (https://en.wikipedia.org/wiki/OpenTTD) game (masterserver and content service)"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3979",
Description: `
OpenTTD game
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "3999",
Description: `
Norman distributed scanning service
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4000",
Description: `
"Diablo II (https://en.wikipedia.org/wiki/Diablo_II) game"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4001",
Description: `
"Microsoft Ants (https://en.wikipedia.org/wiki/Microsoft_Ants) game"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"CoreOS etcd (https://en.wikipedia.org/wiki/Etcd) client communication"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4018",
Description: `
"Protocol information and warnings"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4035",
Description: `
"IBM (https://en.wikipedia.org/wiki/IBM) Rational Developer for System z Remote System Explorer Daemon"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4045",
Description: `
"Solaris (https://en.wikipedia.org/wiki/Solaris_(operating_system)) lockd NFS lock daemon/manager"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4050",
Description: `
"Mud Master Chat protocol (MMCP) - Peer-to-peer communications between MUD (https://en.wikipedia.org/wiki/MUD) clients."
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4069",
Description: `
"Minger Email Address Verification Protocol (https://en.wikipedia.org/wiki/Minger_Email_Address_Verification_Protocol)"
IANA Status - Official
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4070",
Description: `
"Amazon Echo (https://en.wikipedia.org/wiki/Amazon_Echo) Dot (Amazon Alexa (https://en.wikipedia.org/wiki/Amazon_Alexa)) streaming connection with Spotify (https://en.wikipedia.org/wiki/Spotify)"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4089",
Description: `
OpenCORE Remote Control Service
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4090",
Description: `
"Kerio (https://en.wikipedia.org/wiki/Kerio_Technologies)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4093",
Description: `
"PxPlus Client server interface ProvideX (https://en.wikipedia.org/wiki/ProvideX)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4096",
Description: `
"Ascom Timeplex (https://en.wikipedia.org/wiki/Ascom_(company)) Bridge Relay Element (BRE)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4105",
Description: `
Shofar (ShofarNexus)
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4111",
Description: `
"Xgrid (https://en.wikipedia.org/wiki/Xgrid)"
IANA Status - Official
TCP - Yes
UDP - Assigned
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4116",
Description: `
Smartcard-TLS
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4125",
Description: `
"Microsoft Remote Web Workplace (https://en.wikipedia.org/wiki/Microsoft_Remote_Web_Workplace) administration"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4172",
Description: `
"Teradici (https://en.wikipedia.org/wiki/Teradici) PCoIP (https://en.wikipedia.org/wiki/PCoIP)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4190",
Description: `
"ManageSieve"
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4198",
Description: `
"Couch Potato Android app"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4201",
Description: `
"TinyMUD (https://en.wikipedia.org/wiki/TinyMUD) and various derivatives"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4222",
Description: `
"NATS server default port"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4226",
Description: `
"Aleph One (https://en.wikipedia.org/wiki/Aleph_One_(computer_game)), a computer game"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4242",
Description: `
"Orthanc (https://en.wikipedia.org/wiki/Orthanc_(software)) – DICOM (https://en.wikipedia.org/wiki/DICOM) server"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"Quassel (https://en.wikipedia.org/wiki/Quassel) distributed IRC client"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4243",
Description: `
"Docker (https://en.wikipedia.org/wiki/Docker_(software)) implementations, redistributions, and setups default"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"CrashPlan (https://en.wikipedia.org/wiki/CrashPlan)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4244",
Description: `
"Viber (https://en.wikipedia.org/wiki/Viber)"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4303",
Description: `
Simple Railroad Command Protocol (SRCP)
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4307",
Description: `
"TrueConf (https://en.wikipedia.org/wiki/TrueConf) Client - TrueConf Server media data exchange"
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4321",
Description: `
"Referral Whois (RWhois) Protocol (https://en.wikipedia.org/wiki/RWhois)"
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4444",
Description: `
"Oracle (https://en.wikipedia.org/wiki/Oracle_Corporation) WebCenter Content: Content Server—Intradoc Socket port. (formerly known as Oracle Universal Content Management (https://en.wikipedia.org/wiki/Universal_Content_Management))."
IANA Status - Unofficial
TCP - Yes
UDP - Yes
"Metasploit (https://en.wikipedia.org/wiki/Metasploit)'s default listener port"
IANA Status - Unofficial
TCP - ?
UDP - ?
"Xvfb (https://en.wikipedia.org/wiki/Xvfb) X server virtual frame buffer service"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4444-4445",
Description: `
"I2P (https://en.wikipedia.org/wiki/I2P) HTTP/S proxy"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4486",
Description: `
Integrated Client Message Service (ICMS)
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4488",
Description: `
"Apple Wide Area Connectivity Service, used by Back to My Mac (https://en.wikipedia.org/wiki/Back_to_My_Mac)"
IANA Status - Official
TCP - Yes
UDP - Assigned
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4500",
Description: `
"IPSec NAT Traversal (https://en.wikipedia.org/wiki/IPsec_Passthrough) (RFC 3947 (https://tools.ietf.org/html/rfc3947), RFC 4306 (https://tools.ietf.org/html/rfc4306))"
IANA Status - Official
TCP - Assigned
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4502-4534",
Description: `
Microsoft Silverlight connectable ports under non-elevated trust
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4505-4506",
Description: `
"Salt (https://en.wikipedia.org/wiki/Salt_(software)) master"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4534",
Description: `
"Armagetron Advanced (https://en.wikipedia.org/wiki/Armagetron_Advanced) server default"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4560",
Description: `
"default Log4j (https://en.wikipedia.org/wiki/Log4j) socketappender port"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4567",
Description: `
"Sinatra (https://en.wikipedia.org/wiki/Sinatra_(software)) default server port in development mode (HTTP)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4569",
Description: `
"Inter-Asterisk eXchange (https://en.wikipedia.org/wiki/Inter-Asterisk_eXchange) (IAX2)"
IANA Status - Official
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4604",
Description: `
"Identity Registration Protocol (https://en.wikipedia.org/wiki/Identity_Registration_Protocol)"
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4605",
Description: `
"Direct End to End Secure Chat Protocol (https://en.wikipedia.org/wiki/Direct_End_to_End_Secure_Chat_Protocol)"
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4610-4640",
Description: `
"QualiSystems (https://en.wikipedia.org/wiki/QualiSystems) TestShell Suite Services"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4662",
Description: `
OrbitNet Message Service
IANA Status - Official
TCP - Yes
UDP - Yes
"Default for older versions of eMule (https://en.wikipedia.org/wiki/EMule)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4664",
Description: `
"Google Desktop Search (https://en.wikipedia.org/wiki/Google_Desktop)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4672",
Description: `
"Default for older versions of eMule (https://en.wikipedia.org/wiki/EMule)"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4711",
Description: `
"eMule (https://en.wikipedia.org/wiki/EMule) optional web interface"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4713",
Description: `
"PulseAudio (https://en.wikipedia.org/wiki/PulseAudio) sound server"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4728",
Description: `
"Computer Associates Desktop and Server Management (DMP)/Port Multiplexer"
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4730",
Description: `
"Gearman (https://en.wikipedia.org/wiki/Gearman)'s job server"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4739",
Description: `
"IP Flow Information Export (https://en.wikipedia.org/wiki/IP_Flow_Information_Export)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4747",
Description: `
"Apprentice (https://en.wikipedia.org/wiki/Apprentice_(software))"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4753",
Description: `
SIMON (service and discovery)
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4789",
Description: `
"Virtual eXtensible Local Area Network (VXLAN (https://en.wikipedia.org/wiki/Virtual_Extensible_LAN))"
IANA Status - Official
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4791",
Description: `
"IP Routable RocE (https://en.wikipedia.org/wiki/RDMA_over_Converged_Ethernet) (RoCEv2)"
IANA Status - Official
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4840",
Description: `
"OPC UA Connection Protocol (TCP) and OPC UA Multicast Datagram Protocol (UDP) for OPC Unified Architecture (https://en.wikipedia.org/wiki/OPC_Unified_Architecture) from OPC Foundation (https://en.wikipedia.org/wiki/OPC_Foundation)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4843",
Description: `
"OPC UA TCP Protocol over TLS/SSL for OPC Unified Architecture (https://en.wikipedia.org/wiki/OPC_Unified_Architecture) from OPC Foundation (https://en.wikipedia.org/wiki/OPC_Foundation)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4847",
Description: `
Web Fresh Communication, Quadrion Software & Odorless Entertainment
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4848",
Description: `
Java, Glassfish Application Server administration default
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4894",
Description: `
"LysKOM (https://en.wikipedia.org/wiki/LysKOM) Protocol A"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4944",
Description: `
"DrayTek (https://en.wikipedia.org/wiki/DrayTek) DSL Status Monitoring"
IANA Status - Unofficial
TCP - No
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4949",
Description: `
Munin Resource Monitoring Tool
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "4950",
Description: `
Cylon Controls UC32 Communications Port
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5000",
Description: `
"UPnP (https://en.wikipedia.org/wiki/Universal_Plug_and_Play)—Windows network device interoperability"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"VTun (https://en.wikipedia.org/wiki/VTun), VPN (https://en.wikipedia.org/wiki/VPN) Software"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
"ASP.NET_Core (https://en.wikipedia.org/wiki/ASP.NET_Core) — Development Webserver"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"FlightGear (https://en.wikipedia.org/wiki/FlightGear) multiplayer"
IANA Status - Unofficial
TCP - Unspecified
UDP - Unspecified
"Synology Inc. (https://en.wikipedia.org/wiki/Synology_Inc.) Management Console, File Station, Audio Station"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"Flask (https://en.wikipedia.org/wiki/Flask_(web_framework)) Development Webserver"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"Heroku (https://en.wikipedia.org/wiki/Heroku) console access"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"Docker (https://en.wikipedia.org/wiki/Docker_(software)) Registry"
IANA Status - Unofficial
TCP - ?
UDP - ?
"AT&T U-verse (https://en.wikipedia.org/wiki/AT%26T_U-verse) public, educational, and government access (https://en.wikipedia.org/wiki/Public,_educational,_and_government_access) (PEG) streaming over HTTP (https://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"High-Speed SECS Message Services (https://en.wikipedia.org/wiki/High-Speed_SECS_Message_Services)"
IANA Status - Unofficial
TCP - ?
UDP - ?
"3CX Phone System (https://en.wikipedia.org/wiki/3CX_Phone_System) Legacy Management Console"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5000-5500",
Description: `
"League of Legends (https://en.wikipedia.org/wiki/League_of_Legends), a multiplayer online battle arena (https://en.wikipedia.org/wiki/Multiplayer_online_battle_arena) video game"
IANA Status - Unofficial
TCP - No
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5001",
Description: `
"Slingbox (https://en.wikipedia.org/wiki/Slingbox) and Slingplayer"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"Iperf (https://en.wikipedia.org/wiki/Iperf) (Tool for measuring TCP and UDP bandwidth performance)"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
"Synology Inc. (https://en.wikipedia.org/wiki/Synology_Inc.) Secured Management Console, File Station, Audio Station"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"3CX Phone System (https://en.wikipedia.org/wiki/3CX_Phone_System) Secured Management Console, Secure API"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5002",
Description: `
"ASSA ARX access control system"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5003",
Description: `
"FileMaker (https://en.wikipedia.org/wiki/FileMaker) – name binding and transport"
IANA Status - Official
TCP - Yes
UDP - Assigned
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5004",
Description: `
"Real-time Transport Protocol (https://en.wikipedia.org/wiki/Real-time_Transport_Protocol) media data (RTP) (RFC 3551 (https://tools.ietf.org/html/rfc3551), RFC 4571 (https://tools.ietf.org/html/rfc4571))"
IANA Status - Official
TCP - Yes, and DCCP
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5005",
Description: `
"Real-time Transport Protocol control protocol (https://en.wikipedia.org/wiki/RTP_Control_Protocol) (RTCP) (RFC 3551 (https://tools.ietf.org/html/rfc3551), RFC 4571 (https://tools.ietf.org/html/rfc4571))"
IANA Status - Official
TCP - Yes, and DCCP
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5007",
Description: `
Palo Alto Networks - User-ID agent
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5010",
Description: `
"Registered to: TelePath (the IBM FlowMark workflow-management system (https://en.wikipedia.org/wiki/Workflow-management_system) messaging platform)
The TCP port is now used for: IBM WebSphere MQ (https://en.wikipedia.org/wiki/WebSphere_MQ) Workflow"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5011",
Description: `
"TelePath (the IBM FlowMark workflow-management system (https://en.wikipedia.org/wiki/Workflow-management_system) messaging platform)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5025",
Description: `
"scpi-raw Standard Commands for Programmable Instruments (https://en.wikipedia.org/wiki/Standard_Commands_for_Programmable_Instruments)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5029",
Description: `
Sonic Robo Blast 2 and Sonic Robo Blast 2 Kart servers
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5031",
Description: `
"AVM CAPI-over-TCP (ISDN (https://en.wikipedia.org/wiki/ISDN) over Ethernet (https://en.wikipedia.org/wiki/Ethernet) tunneling)"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5037",
Description: `
Android ADB server
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5044",
Description: `
Standard port in Filebeats/Logstash implementation of Lumberjack protocol.
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5048",
Description: `
Texai Message Service
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5050",
Description: `
"Yahoo! Messenger (https://en.wikipedia.org/wiki/Yahoo!_Messenger)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5051",
Description: `
"ita-agent Symantec (https://en.wikipedia.org/wiki/NortonLifeLock) Intruder Alert"
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5060",
Description: `
"Session Initiation Protocol (https://en.wikipedia.org/wiki/Session_Initiation_Protocol) (SIP)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5061",
Description: `
"Session Initiation Protocol (https://en.wikipedia.org/wiki/Session_Initiation_Protocol) (SIP) over TLS (https://en.wikipedia.org/wiki/Transport_Layer_Security)"
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5062",
Description: `
Localisation access
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5064",
Description: `
"EPICS (https://en.wikipedia.org/wiki/EPICS) Channel Access server"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5065",
Description: `
"EPICS Channel Access repeater beacon"
IANA Status - Official
TCP - Assigned
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5070",
Description: `
"Binary Floor Control Protocol (/w/index.php?title=Binary_Floor_Control_Protocol&action=edit&redlink=1) (BFCP)"
IANA Status - Unofficial
TCP - Yes
UDP - No
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5084",
Description: `
"EPCglobal (https://en.wikipedia.org/wiki/EPCglobal) Low Level Reader Protocol (LLRP (https://en.wikipedia.org/wiki/LLRP))"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5085",
Description: `
"EPCglobal Low Level Reader Protocol (LLRP (https://en.wikipedia.org/wiki/LLRP)) over TLS (https://en.wikipedia.org/wiki/Transport_Layer_Security)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5090",
Description: `
"3CX Phone System (https://en.wikipedia.org/wiki/3CX_Phone_System) 3CX Tunnel Protocol, 3CX App API, 3CX Session Border Controller"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5093",
Description: `
"SafeNet, Inc (https://en.wikipedia.org/wiki/SafeNet) Sentinel LM, Sentinel RMS, License Manager, client-to-server"
IANA Status - Official
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5099",
Description: `
SafeNet, Inc Sentinel LM, Sentinel RMS, License Manager, server-to-server
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5104",
Description: `
"IBM (https://en.wikipedia.org/wiki/IBM) Tivoli Framework (/w/index.php?title=IBM_Tivoli_Framework&action=edit&redlink=1) NetCOOL/Impact HTTP (https://en.wikipedia.org/wiki/HTTP) Service"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5121",
Description: `
"Neverwinter Nights (https://en.wikipedia.org/wiki/Neverwinter_Nights)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5124",
Description: `
"TorgaNET (Micronational (https://en.wikipedia.org/wiki/Micronation) Darknet (https://en.wikipedia.org/wiki/Darknet))"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5125",
Description: `
"TorgaNET (Micronational (https://en.wikipedia.org/wiki/Micronation) Intelligence Darknet (https://en.wikipedia.org/wiki/Darknet))"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5150",
Description: `
"ATMP Ascend Tunnel Management Protocol"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5151",
Description: `
"ESRI (https://en.wikipedia.org/wiki/Environmental_Systems_Research_Institute) SDE Instance"
IANA Status - Official
TCP - Yes
UDP - Unspecified
ESRI SDE Remote Start
IANA Status - Official
TCP - Unspecified
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5154",
Description: `
"BZFlag (https://en.wikipedia.org/wiki/BZFlag)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5172",
Description: `
"PC over IP Endpoint Management"
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5190",
Description: `
"AOL Instant Messenger (https://en.wikipedia.org/wiki/AOL_Instant_Messenger) protocol. The chat app is defunct as of 15 December 2017."
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5198",
Description: `
"EchoLink (https://en.wikipedia.org/wiki/Echolink) VoIP Amateur Radio Software (Voice)"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5199",
Description: `
EchoLink VoIP Amateur Radio Software (Voice)
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5200",
Description: `
EchoLink VoIP Amateur Radio Software (Information)
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5201",
Description: `
"Iperf3 (https://en.wikipedia.org/wiki/Iperf3) (Tool for measuring TCP and UDP bandwidth performance)"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5222",
Description: `
"Extensible Messaging and Presence Protocol (https://en.wikipedia.org/wiki/Extensible_Messaging_and_Presence_Protocol) (XMPP) client connection"
IANA Status - Official
TCP - Yes
UDP - Reserved
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5223",
Description: `
"Apple Push Notification Service (https://en.wikipedia.org/wiki/Apple_Push_Notification_Service)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"Extensible Messaging and Presence Protocol (XMPP) client connection over SSL (https://en.wikipedia.org/wiki/Secure_Sockets_Layer)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5228",
Description: `
HP Virtual Room Service
IANA Status - Official
TCP - Yes
UDP - Unspecified
"Google Play (https://en.wikipedia.org/wiki/Google_Play), Android Cloud to Device Messaging Service (https://en.wikipedia.org/wiki/Android_Cloud_to_Device_Messaging_Service), Google Cloud Messaging (https://en.wikipedia.org/wiki/Google_Cloud_Messaging)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5242",
Description: `
"Viber (https://en.wikipedia.org/wiki/Viber)"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5243",
Description: `
"Viber"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5246",
Description: `
"Control And Provisioning of Wireless Access Points (CAPWAP (https://en.wikipedia.org/wiki/CAPWAP)) CAPWAP control"
IANA Status - Official
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5247",
Description: `
"Control And Provisioning of Wireless Access Points (CAPWAP) CAPWAP data"
IANA Status - Official
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5269",
Description: `
"Extensible Messaging and Presence Protocol (XMPP) server-to-server connection"
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5280",
Description: `
"Extensible Messaging and Presence Protocol (XMPP)"
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5281",
Description: `
"Extensible Messaging and Presence Protocol (XMPP)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5298",
Description: `
"Extensible Messaging and Presence Protocol (XMPP)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5310",
Description: `
"Outlaws (https://en.wikipedia.org/wiki/Outlaws_(1997_video_game)), a 1997 first-person shooter video game"
IANA Status - Official
TCP - Assigned
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5318",
Description: `
"Certificate Management over CMS (https://en.wikipedia.org/wiki/Certificate_Management_over_CMS)"
IANA Status - Official
TCP - Yes
UDP - Reserved
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5349",
Description: `
"STUN (https://en.wikipedia.org/wiki/STUN) over TLS (https://en.wikipedia.org/wiki/Transport_Layer_Security)/DTLS (https://en.wikipedia.org/wiki/Datagram_Transport_Layer_Security), a protocol for NAT traversal (https://en.wikipedia.org/wiki/NAT_traversal)"
IANA Status - Official
TCP - Yes/No
UDP - Yes/No
"TURN (https://en.wikipedia.org/wiki/Traversal_Using_Relay_NAT) over TLS/DTLS, a protocol for NAT traversal"
IANA Status - Official
TCP - Yes/No
UDP - Yes/No
"STUN Behavior Discovery over TLS. See also port 3478."
IANA Status - Official
TCP - Yes
UDP - Reserved
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5351",
Description: `
"NAT Port Mapping Protocol (https://en.wikipedia.org/wiki/NAT_Port_Mapping_Protocol) and Port Control Protocol (https://en.wikipedia.org/wiki/Port_Control_Protocol)—client-requested configuration for connections through network address translators (https://en.wikipedia.org/wiki/Network_Address_Translation) and firewalls (https://en.wikipedia.org/wiki/Firewall_(computing))"
IANA Status - Official
TCP - Reserved
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5353",
Description: `
"Multicast DNS (https://en.wikipedia.org/wiki/Multicast_DNS) (mDNS)"
IANA Status - Official
TCP - Assigned
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5355",
Description: `
"Link-Local Multicast Name Resolution (https://en.wikipedia.org/wiki/LLMNR) (LLMNR), allows hosts (https://en.wikipedia.org/wiki/Host_(network)) to perform name resolution (https://en.wikipedia.org/wiki/Hostname_resolution) for hosts on the same local link (https://en.wikipedia.org/wiki/Local_area_network) (only provided by Windows Vista (https://en.wikipedia.org/wiki/Windows_Vista) and Server 2008 (https://en.wikipedia.org/wiki/Server_2008))"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5357",
Description: `
"Web Services for Devices (https://en.wikipedia.org/wiki/Web_Services_for_Devices) (WSDAPI) (only provided by Windows Vista, Windows 7 and Server 2008)"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5358",
Description: `
"WSDAPI (https://en.wikipedia.org/wiki/Web_Services_for_Devices) Applications to Use a Secure Channel (only provided by Windows Vista, Windows 7 and Server 2008)"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5394",
Description: `
"Kega Fusion, a Sega multi-console emulator"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5402",
Description: `
"Multicast File Transfer Protocol (/w/index.php?title=Multicast_File_Transfer_Protocol&action=edit&redlink=1) (MFTP)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5405",
Description: `
"NetSupport Manager (https://en.wikipedia.org/wiki/NetSupport_Manager)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5412",
Description: `
"IBM (https://en.wikipedia.org/wiki/IBM) Rational Synergy (Telelogic Synergy (https://en.wikipedia.org/wiki/Telelogic_Synergy)) (Continuus CM) Message Router"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5413",
Description: `
"Wonderware (https://en.wikipedia.org/wiki/Wonderware) SuiteLink service"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5417",
Description: `
SNS Agent
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5421",
Description: `
"NetSupport Manager (https://en.wikipedia.org/wiki/NetSupport_Manager)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5432",
Description: `
"PostgreSQL (https://en.wikipedia.org/wiki/PostgreSQL) database system"
IANA Status - Official
TCP - Yes
UDP - Assigned
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5433",
Description: `
"Bouwsoft file/webserver"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5445",
Description: `
"Cisco Unified Video Advantage"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5480",
Description: `
"VMware (https://en.wikipedia.org/wiki/VMware) VAMI (Virtual Appliance Management Infrastructure)—used for initial setup of various administration settings on Virtual Appliances designed using the VAMI architecture."
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5481",
Description: `
"Schneider Electric (https://en.wikipedia.org/wiki/Schneider_Electric)'s ClearSCADA (SCADA (https://en.wikipedia.org/wiki/SCADA) implementation for Windows) — used for client-to-server communication."
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5495",
Description: `
"IBM Cognos TM1 (https://en.wikipedia.org/wiki/TM1) Admin server"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5498",
Description: `
"Hotline (https://en.wikipedia.org/wiki/Hotline_Communications) tracker server connection"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5499",
Description: `
Hotline tracker server discovery
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5500",
Description: `
Hotline control connection
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"VNC (https://en.wikipedia.org/wiki/Virtual_Network_Computing) Remote Frame Buffer RFB protocol (https://en.wikipedia.org/wiki/RFB_protocol)—for incoming listening viewer"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5501",
Description: `
Hotline file transfer connection
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5517",
Description: `
"Setiqueue (https://en.wikipedia.org/wiki/SETI@home#Software) Proxy server client for SETI@Home (https://en.wikipedia.org/wiki/SETI@Home) project"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5550",
Description: `
"Hewlett-Packard (https://en.wikipedia.org/wiki/Hewlett-Packard) Data Protector"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5554",
Description: `
"Fastboot (https://en.wikipedia.org/wiki/Fastboot) default wireless port"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5555",
Description: `
"Oracle (https://en.wikipedia.org/wiki/Oracle_Corporation) WebCenter Content: Inbound Refinery—Intradoc Socket port. (formerly known as Oracle Universal Content Management (https://en.wikipedia.org/wiki/Universal_Content_Management)). Port though often changed during installation"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
"Freeciv (https://en.wikipedia.org/wiki/Freeciv) versions up to 2.0, Hewlett-Packard (https://en.wikipedia.org/wiki/Hewlett-Packard) Data Protector, McAfee EndPoint Encryption (https://en.wikipedia.org/wiki/Comparison_of_disk_encryption_software) Database Server, SAP (https://en.wikipedia.org/wiki/Session_Announcement_Protocol), Default for Microsoft Dynamics CRM 4.0, Softether VPN default port"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5556",
Description: `
"Freeciv (https://en.wikipedia.org/wiki/Freeciv), Oracle WebLogic Server Node Manager"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5568",
Description: `
"Session Data Transport (SDT), a part of Architecture for Control Networks (https://en.wikipedia.org/wiki/Architecture_for_Control_Networks) (ACN)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5601",
Description: `
"Kibana (https://en.wikipedia.org/wiki/Kibana)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5631",
Description: `
"pcANYWHEREdata, Symantec (https://en.wikipedia.org/wiki/NortonLifeLock) pcAnywhere (https://en.wikipedia.org/wiki/Pcanywhere) (version 7.52 and later) data"
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5632",
Description: `
pcANYWHEREstat, Symantec pcAnywhere (version 7.52 and later) status
IANA Status - Official
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5656",
Description: `
"IBM Lotus Sametime (https://en.wikipedia.org/wiki/IBM_Lotus_Sametime) p2p file transfer"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5666",
Description: `
"NRPE (https://en.wikipedia.org/wiki/NRPE) (Nagios (https://en.wikipedia.org/wiki/Nagios))"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5667",
Description: `
NSCA (Nagios)
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5670",
Description: `
"FILEMQ (/w/index.php?title=FILEMQ&action=edit&redlink=1) ZeroMQ File Message Queuing Protocol"
IANA Status - Official
TCP - Yes
UDP - Unspecified
"ZRE-DISC (/w/index.php?title=ZRE-DISC&action=edit&redlink=1) ZeroMQ Realtime Exchange Protocol (Discovery)"
IANA Status - Official
TCP - Unspecified
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5671",
Description: `
"Advanced Message Queuing Protocol (https://en.wikipedia.org/wiki/Advanced_Message_Queuing_Protocol) (AMQP) over TLS (https://en.wikipedia.org/wiki/Transport_Layer_Security)"
IANA Status - Official
TCP - Yes
UDP - Assigned
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5672",
Description: `
"Advanced Message Queuing Protocol (AMQP)"
IANA Status - Official
TCP - Yes, and SCTP
UDP - Assigned
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5683",
Description: `
"Constrained Application Protocol (https://en.wikipedia.org/wiki/Constrained_Application_Protocol) (CoAP)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5684",
Description: `
Constrained Application Protocol Secure (CoAPs)
IANA Status - Official
TCP - Yes/No
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5693",
Description: `
"Nagios (https://en.wikipedia.org/wiki/Nagios) Cross Platform Agent (NCPA)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5701",
Description: `
"Hazelcast (https://en.wikipedia.org/wiki/Hazelcast) default communication port"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5722",
Description: `
"Microsoft RPC, DFSR (SYSVOL) Replication Service"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5718",
Description: `
Microsoft DPM Data Channel (with the agent coordinator)
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5719",
Description: `
Microsoft DPM Data Channel (with the protection agent)
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5723",
Description: `
"System Center Operations Manager (https://en.wikipedia.org/wiki/System_Center_Operations_Manager)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5724",
Description: `
Operations Manager Console
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5741",
Description: `
IDA Discover Port 1
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5742",
Description: `
IDA Discover Port 2
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5800",
Description: `
"VNC (https://en.wikipedia.org/wiki/Virtual_Network_Computing) Remote Frame Buffer RFB protocol (https://en.wikipedia.org/wiki/RFB_protocol) over HTTP (https://en.wikipedia.org/wiki/HTTP)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"ProjectWise Server (https://en.wikipedia.org/wiki/ProjectWise)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5900",
Description: `
"Remote Frame Buffer protocol (https://en.wikipedia.org/wiki/RFB_protocol) (RFB)"
IANA Status - Official
TCP - Yes
UDP - Yes
"Virtual Network Computing (https://en.wikipedia.org/wiki/Virtual_Network_Computing) (VNC) Remote Frame Buffer RFB protocol (https://en.wikipedia.org/wiki/RFB_protocol)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5931",
Description: `
"AMMYY (https://en.wikipedia.org/wiki/AMMYY) admin Remote Control"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5938",
Description: `
"TeamViewer (https://en.wikipedia.org/wiki/TeamViewer) remote desktop protocol"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5984",
Description: `
"CouchDB (https://en.wikipedia.org/wiki/CouchDB) database server"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5985",
Description: `
"Windows PowerShell (https://en.wikipedia.org/wiki/Windows_PowerShell) Default psSession Port Windows Remote Management Service (https://en.wikipedia.org/wiki/WS-Management) (WinRM-HTTP)"
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5986",
Description: `
"Windows PowerShell Default psSession Port Windows Remote Management Service (https://en.wikipedia.org/wiki/WS-Management) (WinRM-HTTPS)"
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "5988-5989",
Description: `
"CIM (https://en.wikipedia.org/wiki/Common_Information_Model_(computing))-XML (DMTF Protocol)"
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6000-6063",
Description: `
"X11 (https://en.wikipedia.org/wiki/X_Window_System)—used between an X client and server over the network"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6005",
Description: `
"Default for BMC Software (https://en.wikipedia.org/wiki/BMC_Software) Control-M/Server (https://en.wikipedia.org/wiki/BMC_Control-M)—Socket used for communication between Control-M processes—though often changed during installation"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"Default for Camfrog (https://en.wikipedia.org/wiki/Camfrog) chat & cam client"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6009",
Description: `
"JD Edwards EnterpriseOne (https://en.wikipedia.org/wiki/JD_Edwards_EnterpriseOne) ERP system JDENet messaging client listener"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6050",
Description: `
"Arcserve (https://en.wikipedia.org/wiki/Arcserve) backup"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6051",
Description: `
Arcserve backup
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6086",
Description: `
"Peer Distributed Transfer Protocol (https://en.wikipedia.org/wiki/Peer_Distributed_Transfer_Protocol) (PDTP), FTP like file server in a P2P network"
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6100",
Description: `
"Vizrt (https://en.wikipedia.org/wiki/Vizrt) System"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"Ventrilo (https://en.wikipedia.org/wiki/Ventrilo) authentication for version 3"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6101",
Description: `
"Backup Exec Agent Browser"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6110",
Description: `
"softcm, HP (https://en.wikipedia.org/wiki/Hewlett-Packard) Softbench (https://en.wikipedia.org/wiki/Softbench) CM"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6111",
Description: `
"spc, HP (https://en.wikipedia.org/wiki/Hewlett-Packard) Softbench (https://en.wikipedia.org/wiki/Softbench) Sub-Process Control"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6112",
Description: `
dtspcd, execute commands and launch applications remotely
IANA Status - Official
TCP - Yes
UDP - Yes
"Blizzard (https://en.wikipedia.org/wiki/Blizzard_Entertainment)'s Battle.net (https://en.wikipedia.org/wiki/Battle.net) gaming service and some games, ArenaNet (https://en.wikipedia.org/wiki/ArenaNet) gaming service, Relic (https://en.wikipedia.org/wiki/Relic_Entertainment) gaming service"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
"Club Penguin (https://en.wikipedia.org/wiki/Club_Penguin) Disney online game for kids"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6113",
Description: `
"Club Penguin (https://en.wikipedia.org/wiki/Club_Penguin) Disney online game for kids, Used by some Blizzard (https://en.wikipedia.org/wiki/Blizzard_Entertainment) games"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6136",
Description: `
"ObjectDB (https://en.wikipedia.org/wiki/ObjectDB) database server"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6159",
Description: `
"ARINC (https://en.wikipedia.org/wiki/ARINC) 840 EFB (https://en.wikipedia.org/wiki/Electronic_flight_bag) Application Control Interface"
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6200",
Description: `
"Oracle WebCenter (https://en.wikipedia.org/wiki/Oracle_WebCenter) Content Portable: Content Server (With Native UI) and Inbound Refinery"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6201",
Description: `
Oracle WebCenter Content Portable: Admin
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6225",
Description: `
Oracle WebCenter Content Portable: Content Server Web UI
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6227",
Description: `
Oracle WebCenter Content Portable: JavaDB
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6240",
Description: `
Oracle WebCenter Content Portable: Capture
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6244",
Description: `
Oracle WebCenter Content Portable: Content Server—Intradoc Socket port
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6255",
Description: `
Oracle WebCenter Content Portable: Inbound Refinery—Intradoc Socket port
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6257",
Description: `
"WinMX (https://en.wikipedia.org/wiki/WinMX) (see also 6699)"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6260",
Description: `
planet M.U.L.E.
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6262",
Description: `
"Sybase Advantage Database Server (https://en.wikipedia.org/wiki/Advantage_Database_Server)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6343",
Description: `
"SFlow (https://en.wikipedia.org/wiki/SFlow), sFlow traffic monitoring"
IANA Status - Official
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6346",
Description: `
"gnutella-svc (https://en.wikipedia.org/wiki/Gnutella), gnutella (FrostWire (https://en.wikipedia.org/wiki/FrostWire), Limewire (https://en.wikipedia.org/wiki/Limewire), Shareaza (https://en.wikipedia.org/wiki/Shareaza), etc.)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6347",
Description: `
gnutella-rtr, Gnutella alternate
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6350",
Description: `
App Discovery and Access Protocol
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6379",
Description: `
"Redis (https://en.wikipedia.org/wiki/Redis) key-value data store"
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6389",
Description: `
"EMC (https://en.wikipedia.org/wiki/EMC_Corporation) CLARiiON (https://en.wikipedia.org/wiki/CLARiiON)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6432",
Description: `
PgBouncer—A connection pooler for PostgreSQL
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6436",
Description: `
"Leap Motion (https://en.wikipedia.org/wiki/Leap_Motion) Websocket Server TLS"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6437",
Description: `
Leap Motion Websocket Server
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6444",
Description: `
"Sun Grid Engine (https://en.wikipedia.org/wiki/Sun_Grid_Engine) Qmaster Service"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6445",
Description: `
Sun Grid Engine Execution Service
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6463-6472",
Description: `
"Discord (https://en.wikipedia.org/wiki/Discord_(software)) RPC"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6464",
Description: `
"Port assignment for medical device communication in accordance to IEEE 11073-20701 (https://en.wikipedia.org/wiki/ISO/IEEE_11073)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6502",
Description: `
Netop Remote Control
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6513",
Description: `
"NETCONF (https://en.wikipedia.org/wiki/NETCONF) over TLS (https://en.wikipedia.org/wiki/Transport_Layer_Security)"
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6514",
Description: `
"Syslog over TLS"
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6515",
Description: `
"Elipse (https://en.wikipedia.org/wiki/Elipse_Software) RPC Protocol (REC)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6516",
Description: `
"Windows Admin Center (https://en.wikipedia.org/wiki/Windows_Admin_Center)"
IANA Status - Unofficial
TCP - Unspecified
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6543",
Description: `
"Pylons project#Pyramid (https://en.wikipedia.org/wiki/Pylons_project#Pyramid) Default Pylons Pyramid web service port"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6556",
Description: `
"Check MK (https://en.wikipedia.org/wiki/Check_MK) Agent"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6566",
Description: `
"SANE (https://en.wikipedia.org/wiki/Scanner_Access_Now_Easy) (Scanner Access Now Easy)—SANE network scanner daemon"
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6560-6561",
Description: `
"Speech-Dispatcher (/w/index.php?title=Speech-Dispatcher&action=edit&redlink=1) daemon"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6571",
Description: `
"Windows Live FolderShare (https://en.wikipedia.org/wiki/Windows_Live_FolderShare) client"
IANA Status - Unofficial
TCP - Unspecified
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6600",
Description: `
"Microsoft Hyper-V (https://en.wikipedia.org/wiki/Hyper-V) Live"
IANA Status - Official
TCP - Yes
UDP - Unspecified
"Music Player Daemon (https://en.wikipedia.org/wiki/Music_Player_Daemon) (MPD)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6601",
Description: `
"Microsoft Forefront Threat Management Gateway (https://en.wikipedia.org/wiki/Microsoft_Forefront_Threat_Management_Gateway)"
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6602",
Description: `
Microsoft Windows WSS Communication
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6619",
Description: `
"odette-ftps, Odette File Transfer Protocol (https://en.wikipedia.org/wiki/OFTP) (OFTP (https://en.wikipedia.org/wiki/OFTP)) over TLS (https://en.wikipedia.org/wiki/Transport_Layer_Security)/SSL (https://en.wikipedia.org/wiki/Secure_Sockets_Layer)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6622",
Description: `
Multicast FTP
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6653",
Description: `
"OpenFlow (https://en.wikipedia.org/wiki/OpenFlow)"
IANA Status - Official
TCP - Yes
UDP - Assigned
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6660-6664",
Description: `
"Internet Relay Chat (https://en.wikipedia.org/wiki/Internet_Relay_Chat) (IRC)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6665-6669",
Description: `
"Internet Relay Chat (https://en.wikipedia.org/wiki/Internet_Relay_Chat) (IRC)"
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6679",
Description: `
Osorno Automation Protocol (OSAUT)
IANA Status - Official
TCP - Yes
UDP - Yes
"IRC (https://en.wikipedia.org/wiki/Internet_Relay_Chat) SSL (https://en.wikipedia.org/wiki/Secure_Sockets_Layer) (Secure Internet Relay Chat)—often used"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6690",
Description: `
Synology Cloud station
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6697",
Description: `
"IRC (https://en.wikipedia.org/wiki/Internet_Relay_Chat) SSL (https://en.wikipedia.org/wiki/Secure_Sockets_Layer) (Secure Internet Relay Chat)—often used"
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6699",
Description: `
"WinMX (https://en.wikipedia.org/wiki/WinMX) (see also 6257)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6715",
Description: `
AberMUD and derivatives default port
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6771",
Description: `
"BitTorrent Local Peer Discovery (https://en.wikipedia.org/wiki/Local_Peer_Discovery)"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6783-6785",
Description: `
"Splashtop Remote (https://en.wikipedia.org/wiki/Splashtop_Remote) server broadcast"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6881-6887",
Description: `
"BitTorrent (https://en.wikipedia.org/wiki/BitTorrent_(protocol)) part of full range of ports used most often"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6888",
Description: `
MUSE
IANA Status - Official
TCP - Yes
UDP - Yes
BitTorrent part of full range of ports used most often
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6889-6890",
Description: `
BitTorrent part of full range of ports used most often
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6891-6900",
Description: `
BitTorrent part of full range of ports used most often
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6891-6900",
Description: `
"Windows Live Messenger (https://en.wikipedia.org/wiki/Windows_Live_Messenger) (File transfer)"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6901",
Description: `
"Windows Live Messenger (https://en.wikipedia.org/wiki/Windows_Live_Messenger) (Voice)"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
BitTorrent part of full range of ports used most often
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6902-6968",
Description: `
BitTorrent part of full range of ports used most often
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6969",
Description: `
acmsoda
IANA Status - Official
TCP - Yes
UDP - Yes
BitTorrent tracker
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "6970-6999",
Description: `
BitTorrent part of full range of ports used most often
IANA Status - Unofficial
TCP - Yes
UDP - Yes
"QuickTime Streaming Server (https://en.wikipedia.org/wiki/QuickTime_Streaming_Server)"
IANA Status - Unofficial
TCP - Unspecified
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7000",
Description: `
"Default for Vuze (https://en.wikipedia.org/wiki/Vuze)'s built-in HTTPS (https://en.wikipedia.org/wiki/HTTPS) Bittorrent Tracker (https://en.wikipedia.org/wiki/Bittorrent_Tracker)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"Avira (https://en.wikipedia.org/wiki/Avira) Server Management Console"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7001",
Description: `
Avira Server Management Console
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"Default for BEA (https://en.wikipedia.org/wiki/BEA_Systems) WebLogic Server (https://en.wikipedia.org/wiki/WebLogic)'s HTTP (https://en.wikipedia.org/wiki/HTTP) server, though often changed during installation"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7002",
Description: `
Default for BEA WebLogic Server's HTTPS server, though often changed during installation
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7005",
Description: `
"Default for BMC Software (https://en.wikipedia.org/wiki/BMC_Software) Control-M/Server (https://en.wikipedia.org/wiki/BMC_Control-M) and Control-M/Agent for Agent-to-Server, though often changed during installation"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7006",
Description: `
Default for BMC Software Control-M/Server and Control-M/Agent for Server-to-Agent, though often changed during installation
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7010",
Description: `
"Default for Cisco AON AMC (AON Management Console)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7022",
Description: `
"Database mirroring endpoints"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7023",
Description: `
Bryan Wilcutt T2-NMCS Protocol for SatCom Modems
IANA Status - Official
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7025",
Description: `
"Zimbra LMTP (https://en.wikipedia.org/wiki/Local_Mail_Transfer_Protocol) [mailbox]—local mail delivery"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7047",
Description: `
"Zimbra (https://en.wikipedia.org/wiki/Zimbra) conversion server"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7070",
Description: `
"Real Time Streaming Protocol (https://en.wikipedia.org/wiki/Real_Time_Streaming_Protocol) (RTSP), used by QuickTime Streaming Server (https://en.wikipedia.org/wiki/QuickTime_Streaming_Server). TCP is used by default, UDP is used as an alternate."
IANA Status - Unofficial
TCP - Yes
UDP - Yes/No
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7133",
Description: `
"Enemy Territory: Quake Wars (https://en.wikipedia.org/wiki/Enemy_Territory:_Quake_Wars)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7144",
Description: `
"Peercast"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7145",
Description: `
"Peercast"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7171",
Description: `
"Tibia (https://en.wikipedia.org/wiki/Tibia_(computer_game))"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7262",
Description: `
CNAP (Calypso Network Access Protocol)
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7272",
Description: `
WatchMe - WatchMe Monitoring
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7306",
Description: `
"Zimbra mysql [mailbox]"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7307",
Description: `
"Zimbra mysql [logger]"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7312",
Description: `
"Sibelius (https://en.wikipedia.org/wiki/Sibelius_notation_program) License Server"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7396",
Description: `
"Web control interface for Folding@home v7.3.6 (https://en.wikipedia.org/wiki/Folding@home#V7) and later"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7400",
Description: `
"RTPS (Real Time Publish Subscribe) DDS (https://en.wikipedia.org/wiki/Data_Distribution_Service) Discovery"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7401",
Description: `
"RTPS (Real Time Publish Subscribe) DDS (https://en.wikipedia.org/wiki/Data_Distribution_Service) User-Traffic"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7402",
Description: `
"RTPS (Real Time Publish Subscribe) DDS (https://en.wikipedia.org/wiki/Data_Distribution_Service) Meta-Traffic"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7471",
Description: `
Stateless Transport Tunneling (STT)
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7473",
Description: `
"Rise: The Vieneo Province (https://en.wikipedia.org/wiki/Rise:_The_Vieneo_Province)"
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7474",
Description: `
"Neo4J Server webadmin"
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7478",
Description: `
"Default port used by Open iT (https://en.wikipedia.org/wiki/Open_iT) Server."
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7542",
Description: `
"Saratoga file transfer protocol"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7547",
Description: `
"CPE WAN Management Protocol (CWMP) Technical Report 069 (https://en.wikipedia.org/wiki/TR-069)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7575",
Description: `
"Populous: The Beginning (https://en.wikipedia.org/wiki/Populous:_The_Beginning) server"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7624",
Description: `
"Instrument Neutral Distributed Interface (https://en.wikipedia.org/wiki/Instrument_Neutral_Distributed_Interface)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7631",
Description: `
ERLPhase
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7634",
Description: `
hddtemp—Utility to monitor hard drive temperature
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7652-7654",
Description: `
"I2P (https://en.wikipedia.org/wiki/I2P) anonymizing overlay network"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7655",
Description: `
I2P SAM Bridge Socket API
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7656-7660",
Description: `
I2P anonymizing overlay network
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7670",
Description: `
"BrettspielWelt (https://en.wikipedia.org/wiki/BrettspielWelt) BSW Boardgame Portal"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7680",
Description: `
"Delivery Optimization for Windows 10 (https://en.wikipedia.org/wiki/Windows_10)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7687",
Description: `
"Bolt (https://en.wikipedia.org/wiki/Bolt_(network_protocol)) database connection"
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7707-7708",
Description: `
"Killing Floor (https://en.wikipedia.org/wiki/Killing_Floor_(2009_video_game))"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7717",
Description: `
Killing Floor
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7777",
Description: `
"iChat (https://en.wikipedia.org/wiki/IChat) server file transfer proxy"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"Oracle Cluster File System 2"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"Windows backdoor program tini.exe default"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"Just Cause 2: Multiplayer Mod Server"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"Terraria (https://en.wikipedia.org/wiki/Terraria) default server"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
San Andreas Multiplayer (SA-MP) default port server
IANA Status - Unofficial
TCP - Unspecified
UDP - Unspecified
SCP: Secret Laboratory Multiplayer Server
IANA Status - Unofficial
TCP - Unspecified
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7777-7788",
Description: `
"Unreal Tournament series default server"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7831",
Description: `
"Default used by Smartlaunch Internet Cafe Administration software"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7880",
Description: `
"PowerSchool Gradebook Server"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7890",
Description: `
Default that will be used by the iControl Internet Cafe Suite Administration software
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7915",
Description: `
"Default for YSFlight server"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7935",
Description: `
"Fixed port used for Adobe Flash Debug Player to communicate with a debugger (Flash IDE, Flex Builder or fdb)."
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7946",
Description: `
"Docker Swarm communication among nodes"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "7990",
Description: `
"Atlassian Bitbucket (https://en.wikipedia.org/wiki/Bitbucket) (default port)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8000",
Description: `
"Commonly used for Internet radio streams such as SHOUTcast (https://en.wikipedia.org/wiki/SHOUTcast), Icecast (https://en.wikipedia.org/wiki/Icecast) and iTunes Radio (https://en.wikipedia.org/wiki/ITunes_Radio)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"DynamoDB (https://en.wikipedia.org/wiki/DynamoDB) Local"
IANA Status - Unofficial
TCP - ?
UDP - ?
"Django (https://en.wikipedia.org/wiki/Django_(web_framework)) Development Webserver"
IANA Status - Unofficial
TCP - ?
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8005",
Description: `
"Tomcat (https://en.wikipedia.org/wiki/Apache_Tomcat) remote shutdown"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8006",
Description: `
"Quest AppAssure (https://en.wikipedia.org/wiki/Quest_AppAssure) 5 API"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"Proxmox Virtual Environment (https://en.wikipedia.org/wiki/Proxmox_Virtual_Environment) admin web interface"
IANA Status - Unofficial
TCP - Yes
UDP - No
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8007",
Description: `
"Quest AppAssure 5 Engine"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8008",
Description: `
"Alternative port for HTTP (https://en.wikipedia.org/wiki/HTTP). See also ports 80 and 8080."
IANA Status - Official
TCP - Yes
UDP - Yes
"IBM HTTP Server (https://en.wikipedia.org/wiki/IBM_HTTP_Server) administration default"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"iCal (https://en.wikipedia.org/wiki/ICal), a calendar application by Apple (https://en.wikipedia.org/wiki/Apple,_Inc.)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"Matrix (https://en.wikipedia.org/wiki/Matrix_(protocol)) homeserver federation over HTTP"
IANA Status - Unofficial
TCP - Yes
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8009",
Description: `
"Apache JServ Protocol (https://en.wikipedia.org/wiki/Apache_JServ_Protocol) (ajp13)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8010",
Description: `
"Buildbot (https://en.wikipedia.org/wiki/Buildbot) Web status page"
IANA Status - Unofficial
TCP - Yes
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8042",
Description: `
"Orthanc (https://en.wikipedia.org/wiki/Orthanc_(software)) – REST API over HTTP"
IANA Status - Unofficial
TCP - ?
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8069",
Description: `
"OpenERP (https://en.wikipedia.org/wiki/OpenERP) 5.0 XML-RPC protocol"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8070",
Description: `
"OpenERP 5.0 NET-RPC protocol"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8074",
Description: `
"Gadu-Gadu (https://en.wikipedia.org/wiki/Gadu-Gadu)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8075",
Description: `
"Killing Floor web administration interface"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8080",
Description: `
"Alternative port for HTTP (https://en.wikipedia.org/wiki/HTTP). See also ports 80 and 8008."
IANA Status - Official
TCP - Yes
UDP - Yes
"Apache Tomcat (https://en.wikipedia.org/wiki/Apache_Tomcat)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"Atlassian JIRA (https://en.wikipedia.org/wiki/Jira_(software)) applications"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8088",
Description: `
"Asterisk (https://en.wikipedia.org/wiki/Asterisk_(PBX)) management access via HTTP"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8089",
Description: `
"Splunk (https://en.wikipedia.org/wiki/Splunk) daemon management"
IANA Status - Unofficial
TCP - Yes
UDP - No
"Fritz!Box (https://en.wikipedia.org/wiki/Fritz!Box) automatic TR-069 (https://en.wikipedia.org/wiki/TR-069) configuration"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8090",
Description: `
"Atlassian Confluence (https://en.wikipedia.org/wiki/Atlassian_Confluence)"
IANA Status - Unofficial
TCP - ?
UDP - ?
"Coral Content Distribution Network (https://en.wikipedia.org/wiki/Coral_Content_Distribution_Network) (legacy; 80 and 8080 now supported)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"Matrix identity server"
IANA Status - Unofficial
TCP - ?
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8091",
Description: `
"CouchBase (https://en.wikipedia.org/wiki/CouchBase) web administration"
IANA Status - Unofficial
TCP - ?
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8092",
Description: `
"CouchBase API"
IANA Status - Unofficial
TCP - ?
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8111",
Description: `
"JOSM (https://en.wikipedia.org/wiki/JOSM) Remote Control"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8112",
Description: `
PAC Pacifica Coin
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8116",
Description: `
"Check Point (https://en.wikipedia.org/wiki/Check_Point) Cluster Control Protocol"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8118",
Description: `
"Privoxy (https://en.wikipedia.org/wiki/Privoxy)—advertisement-filtering Web proxy"
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8123",
Description: `
"Polipo (https://en.wikipedia.org/wiki/Polipo) Web proxy"
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8139",
Description: `
"Puppet (software) (https://en.wikipedia.org/wiki/Puppet_(software)) Client agent"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8140",
Description: `
Puppet (software) Master server
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8172",
Description: `
"Microsoft (https://en.wikipedia.org/wiki/Microsoft) Remote Administration for IIS Manager"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8184",
Description: `
"NCSA Brown Dog (https://en.wikipedia.org/wiki/NCSA_Brown_Dog) Data Access Proxy"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8194-8195",
Description: `
"Bloomberg Terminal (https://en.wikipedia.org/wiki/Bloomberg_Terminal)"
IANA Status - Official
TCP - ?
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8200",
Description: `
"GoToMyPC (https://en.wikipedia.org/wiki/GoToMyPC)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
MiniDLNA media server Web Interface
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8222",
Description: `
"VMware (https://en.wikipedia.org/wiki/VMware) VI Web Access via HTTP"
IANA Status - Unofficial
TCP - ?
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8243",
Description: `
"HTTPS (https://en.wikipedia.org/wiki/HTTPS) listener for Apache Synapse (https://en.wikipedia.org/wiki/Apache_Synapse)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8245",
Description: `
"Dynamic DNS (https://en.wikipedia.org/wiki/Dynamic_DNS) for at least No-IP (https://en.wikipedia.org/wiki/No-IP) and DyDNS"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8280",
Description: `
"HTTP (https://en.wikipedia.org/wiki/HTTP) listener for Apache Synapse (https://en.wikipedia.org/wiki/Apache_Synapse)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8281",
Description: `
HTTP Listener for Gatecraft Plugin
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8291",
Description: `
"Winbox—Default on a MikroTik RouterOS for a Windows application used to administer MikroTik RouterOS"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8303",
Description: `
"Teeworlds (https://en.wikipedia.org/wiki/Teeworlds) Server"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8332",
Description: `
"Bitcoin (https://en.wikipedia.org/wiki/Bitcoin) JSON-RPC (https://en.wikipedia.org/wiki/JSON-RPC) server"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8333",
Description: `
"Bitcoin (https://en.wikipedia.org/wiki/Bitcoin)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"VMware (https://en.wikipedia.org/wiki/VMware) VI Web Access via HTTPS"
IANA Status - Unofficial
TCP - ?
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8337",
Description: `
"VisualSVN Distributed File System Service (VDFS)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8384",
Description: `
"Syncthing (https://en.wikipedia.org/wiki/Syncthing) web GUI"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8388",
Description: `
"Shadowsocks (https://en.wikipedia.org/wiki/Shadowsocks) proxy server"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8443",
Description: `
"SW Soft Plesk (https://en.wikipedia.org/wiki/SW_Soft_Plesk) Control Panel"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"Apache Tomcat (https://en.wikipedia.org/wiki/Apache_Tomcat) SSL"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"Promise (https://en.wikipedia.org/wiki/Promise_Technology) WebPAM SSL"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"iCal (https://en.wikipedia.org/wiki/ICal) over SSL (https://en.wikipedia.org/wiki/Secure_Socket_Layer)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"MineOs (/w/index.php?title=MineOs&action=edit&redlink=1) WebUi"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8444",
Description: `
"Bitmessage (https://en.wikipedia.org/wiki/Bitmessage)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8448",
Description: `
"Matrix homeserver federation over HTTPS"
IANA Status - Unofficial
TCP - Yes
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8484",
Description: `
"MapleStory (https://en.wikipedia.org/wiki/MapleStory) Login Server"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8500",
Description: `
"Adobe ColdFusion (https://en.wikipedia.org/wiki/Adobe_ColdFusion) built-in web server"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8530",
Description: `
"Windows Server Update Services (https://en.wikipedia.org/wiki/Windows_Server_Update_Services) over HTTP (https://en.wikipedia.org/wiki/HTTP)"
IANA Status - Unofficial
TCP - ?
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8531",
Description: `
"Windows Server Update Services over HTTPS (https://en.wikipedia.org/wiki/HTTPS)"
IANA Status - Unofficial
TCP - ?
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8580",
Description: `
"Freegate (https://en.wikipedia.org/wiki/Freegate), an Internet anonymizer (https://en.wikipedia.org/wiki/Anonymizer) and proxy tool"
IANA Status - Unofficial
TCP - ?
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8629",
Description: `
"Tibero database (https://en.wikipedia.org/wiki/Tibero)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8642",
Description: `
"Lotus Notes Traveler (https://en.wikipedia.org/wiki/IBM_Lotus_Notes_Traveler) auto synchronization for Windows Mobile and Nokia devices"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8691",
Description: `
"Ultra Fractal (https://en.wikipedia.org/wiki/Ultra_Fractal), a fractal (https://en.wikipedia.org/wiki/Fractal) generation and rendering software application (https://en.wikipedia.org/wiki/Graphic_art_software) – distributed calculations over networked computers"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8765",
Description: `
"Default port of a local GUN relay peer that the Internet Archive (https://en.wikipedia.org/wiki/Internet_Archive) and others use as a decentralized mirror for censorship resistance."
IANA Status - Unofficial
TCP - Yes
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8767",
Description: `
"Voice channel of TeamSpeak 2 (https://en.wikipedia.org/wiki/TeamSpeak_2), a proprietary Voice over IP (https://en.wikipedia.org/wiki/Voice_over_IP) protocol targeted at gamers (https://en.wikipedia.org/wiki/Gamer)"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8834",
Description: `
"Nessus (https://en.wikipedia.org/wiki/Nessus_(software)), a vulnerability scanner (https://en.wikipedia.org/wiki/Vulnerability_scanner) – remote XML-RPC (https://en.wikipedia.org/wiki/XML-RPC) web server"
IANA Status - Unofficial
TCP - ?
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8840",
Description: `
"Opera Unite (/w/index.php?title=Opera_Unite&action=edit&redlink=1), an extensible framework (https://en.wikipedia.org/wiki/Software_framework) for web applications"
IANA Status - Unofficial
TCP - ?
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8880",
Description: `
"Alternate port of CDDB (https://en.wikipedia.org/wiki/CDDB) (Compact Disc Database) protocol, used to look up audio CD (compact disc (https://en.wikipedia.org/wiki/Compact_disc)) information over the Internet (https://en.wikipedia.org/wiki/Internet). See also port 888."
IANA Status - Official
TCP - Yes
UDP - Unspecified
"IBM WebSphere Application Server (https://en.wikipedia.org/wiki/IBM_WebSphere_Application_Server) SOAP (https://en.wikipedia.org/wiki/SOAP) connector"
IANA Status - Unofficial
TCP - ?
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8883",
Description: `
"Secure MQTT (https://en.wikipedia.org/wiki/MQTT) (MQTT over TLS)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8887",
Description: `
"HyperVM (https://en.wikipedia.org/wiki/HyperVM) over HTTP"
IANA Status - Unofficial
TCP - ?
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8888",
Description: `
"HyperVM over HTTPS (https://en.wikipedia.org/wiki/HTTPS)"
IANA Status - Unofficial
TCP - ?
UDP - ?
"Freenet (https://en.wikipedia.org/wiki/Freenet) web UI (localhost only)"
IANA Status - Unofficial
TCP - ?
UDP - Yes
"Default for IPython (https://en.wikipedia.org/wiki/IPython) / Jupyter (https://en.wikipedia.org/wiki/Jupyter) notebook dashboards"
IANA Status - Unofficial
TCP - ?
UDP - ?
"MAMP (https://en.wikipedia.org/wiki/MAMP)"
IANA Status - Unofficial
TCP - ?
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8889",
Description: `
"MAMP"
IANA Status - Unofficial
TCP - ?
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8983",
Description: `
"Apache Solr (https://en.wikipedia.org/wiki/Apache_Solr)"
IANA Status - Unofficial
TCP - ?
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8997",
Description: `
"Alternate port for I2P (https://en.wikipedia.org/wiki/I2P) Monotone Proxy"
IANA Status - Unofficial
TCP - ?
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8998",
Description: `
"I2P Monotone Proxy"
IANA Status - Unofficial
TCP - ?
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "8999",
Description: `
"Alternate port for I2P Monotone Proxy"
IANA Status - Unofficial
TCP - ?
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9000",
Description: `
"SonarQube (https://en.wikipedia.org/wiki/SonarQube) Web Server"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"DBGp (https://en.wikipedia.org/wiki/DBGp)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"SqueezeCenter (https://en.wikipedia.org/wiki/SqueezeCenter) web server & streaming"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"UDPCast (https://en.wikipedia.org/wiki/UDPCast)"
IANA Status - Unofficial
TCP - Unspecified
UDP - Unspecified
"Play! Framework web server"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"Hadoop (https://en.wikipedia.org/wiki/Hadoop_Distributed_File_System) NameNode default port"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"PHP-FPM (https://en.wikipedia.org/wiki/PHP-FPM) default port"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"QBittorrent (https://en.wikipedia.org/wiki/QBittorrent)'s embedded torrent tracker default port"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9001",
Description: `
"ETL Service Manager"
IANA Status - Official
TCP - Yes
UDP - Yes
"Microsoft SharePoint (https://en.wikipedia.org/wiki/Microsoft_SharePoint) authoring environment"
IANA Status - Unofficial
TCP - Unspecified
UDP - Unspecified
"cisco-xremote router configuration"
IANA Status - Unofficial
TCP - Unspecified
UDP - Unspecified
"Tor (https://en.wikipedia.org/wiki/Tor_(anonymity_network)) network default"
IANA Status - Unofficial
TCP - Unspecified
UDP - Unspecified
"DBGp (https://en.wikipedia.org/wiki/DBGp) Proxy"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"HSQLDB (https://en.wikipedia.org/wiki/HSQLDB) default port"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9002",
Description: `
Newforma Server comms
IANA Status - Unofficial
TCP - Unspecified
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9006",
Description: `
De-Commissioned Port
IANA Status - Official
TCP - Unspecified
UDP - Unspecified
"Tomcat (https://en.wikipedia.org/wiki/Apache_Tomcat) in standalone mode"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9030",
Description: `
"Tor (https://en.wikipedia.org/wiki/Tor_(anonymity_network)) often used"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9042",
Description: `
"Apache Cassandra (https://en.wikipedia.org/wiki/Apache_Cassandra) native protocol clients"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9043",
Description: `
"WebSphere Application Server (https://en.wikipedia.org/wiki/WebSphere_Application_Server) Administration Console secure"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9050-9051",
Description: `
"Tor (https://en.wikipedia.org/wiki/Tor_(anonymity_network)) (SOCKS-5 proxy client)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9060",
Description: `
"WebSphere Application Server (https://en.wikipedia.org/wiki/WebSphere_Application_Server) Administration Console"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9080",
Description: `
"glrpc, Groove (https://en.wikipedia.org/wiki/Microsoft_Groove) Collaboration software (https://en.wikipedia.org/wiki/Collaboration_software) GLRPC"
IANA Status - Official
TCP - Yes
UDP - Yes
"WebSphere Application Server (https://en.wikipedia.org/wiki/WebSphere_Application_Server) HTTP (https://en.wikipedia.org/wiki/HTTP) Transport (port 1) default (https://en.wikipedia.org/wiki/Default_(computer_science))"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
Remote Potato by FatAttitude, Windows Media Center addon
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
ServerWMC, Windows Media Center addon
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9090",
Description: `
"Prometheus (https://en.wikipedia.org/wiki/Prometheus_(software)) metrics server"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"Openfire (https://en.wikipedia.org/wiki/Openfire) Administration Console"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"SqueezeCenter (https://en.wikipedia.org/wiki/SqueezeCenter) control (CLI)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"Cherokee (https://en.wikipedia.org/wiki/Cherokee_(web_server)) Admin Panel"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9091",
Description: `
"Openfire (https://en.wikipedia.org/wiki/Openfire) Administration Console (SSL Secured)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"Transmission (BitTorrent client) (https://en.wikipedia.org/wiki/Transmission_(BitTorrent_client)) Web Interface"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9092",
Description: `
"H2 (DBMS) (https://en.wikipedia.org/wiki/H2_(DBMS)) Database Server"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"Apache Kafka (https://en.wikipedia.org/wiki/Apache_Kafka) A Distributed Streaming Platform"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9100",
Description: `
"PDL (https://en.wikipedia.org/wiki/Page_description_language) Data Stream, used for printing to certain network printers"
IANA Status - Official
TCP - Yes
UDP - Assigned
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9101",
Description: `
"Bacula (https://en.wikipedia.org/wiki/Bacula) Director"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9102",
Description: `
"Bacula (https://en.wikipedia.org/wiki/Bacula) File Daemon"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9103",
Description: `
"Bacula (https://en.wikipedia.org/wiki/Bacula) Storage Daemon"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9119",
Description: `
"MXit (https://en.wikipedia.org/wiki/MXit) Instant Messenger"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9150",
Description: `
"Tor (https://en.wikipedia.org/wiki/Tor_(anonymity_network)) Browser"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9191",
Description: `
Sierra Wireless Airlink
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9199",
Description: `
Avtex LLC—qStats
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9200",
Description: `
"Elasticsearch—default Elasticsearch port"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9217",
Description: `
iPass Platform Service
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9293",
Description: `
"Sony PlayStation RemotePlay"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9300",
Description: `
"IBM Cognos BI (https://en.wikipedia.org/wiki/IBM_Cognos_Business_Intelligence)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9303",
Description: `
"D-Link Shareport (/w/index.php?title=D-Link_Shareport&action=edit&redlink=1) Share storage and MFP printers"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9306",
Description: `
"Sphinx (https://en.wikipedia.org/wiki/Sphinx_(search_engine)) Native API"
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9309",
Description: `
"Sony PlayStation Vita Host Collaboration WiFi Data Transfer"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9312",
Description: `
"Sphinx (https://en.wikipedia.org/wiki/Sphinx_(search_engine)) SphinxQL"
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9332",
Description: `
"Litecoin (https://en.wikipedia.org/wiki/Litecoin) JSON-RPC (https://en.wikipedia.org/wiki/JSON-RPC) server"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9333",
Description: `
"Litecoin (https://en.wikipedia.org/wiki/Litecoin)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9339",
Description: `
Used by all Supercell games such as Brawl Stars and Clash of Clans, mobile freemium strategy video games
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9389",
Description: `
"adws, Microsoft (https://en.wikipedia.org/wiki/Microsoft) AD DS (https://en.wikipedia.org/wiki/AD_DS) Web Services, Powershell (https://en.wikipedia.org/wiki/Powershell) uses this port"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9392",
Description: `
OpenVAS Greenbone Security Assistant web interface
IANA Status - Unofficial
TCP - Yes
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9418",
Description: `
"git, Git (https://en.wikipedia.org/wiki/Git_(software)) pack transfer service"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9419",
Description: `
"MooseFS (https://en.wikipedia.org/wiki/Moose_File_System) distributed file system – master control port"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9420",
Description: `
"MooseFS distributed file system – master command port"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9421",
Description: `
"MooseFS distributed file system – master client port"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9422",
Description: `
"MooseFS distributed file system – Chunkservers"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9425",
Description: `
"MooseFS distributed file system – CGI server"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9443",
Description: `
"VMware (https://en.wikipedia.org/wiki/VMware) Websense Triton console (HTTPS port used for accessing and administrating a vCenter Server via the Web Management Interface)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"NCSA Brown Dog (https://en.wikipedia.org/wiki/NCSA_Brown_Dog) Data Tilling Service"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9535",
Description: `
"mngsuite, LANDesk (https://en.wikipedia.org/wiki/Landesk) Management Suite Remote Control"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9536",
Description: `
"laes-bf, IP Fabrics (https://en.wikipedia.org/wiki/IP_Fabrics) Surveillance buffering function"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9600",
Description: `
"Factory Interface Network Service (https://en.wikipedia.org/wiki/Factory_Interface_Network_Service) (FINS), a network protocol used by Omron (https://en.wikipedia.org/wiki/Omron) programmable logic controllers (https://en.wikipedia.org/wiki/Programmable_logic_controller)"
IANA Status - Unofficial
TCP - No
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9675",
Description: `
"Spiceworks (https://en.wikipedia.org/wiki/Spiceworks) Desktop, IT Helpdesk Software"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9676",
Description: `
"Spiceworks (https://en.wikipedia.org/wiki/Spiceworks) Desktop, IT Helpdesk Software"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9695",
Description: `
"Content centric networking (https://en.wikipedia.org/wiki/Content_centric_networking) (CCN, CCNx)"
IANA Status - Official
TCP - ?
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9785",
Description: `
"Viber (https://en.wikipedia.org/wiki/Viber)"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9800",
Description: `
"WebDAV (https://en.wikipedia.org/wiki/WebDAV) Source"
IANA Status - Official
TCP - Yes
UDP - Yes
"WebCT (https://en.wikipedia.org/wiki/WebCT) e-learning portal"
IANA Status - Unofficial
TCP - Unspecified
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9875",
Description: `
"Club Penguin (https://en.wikipedia.org/wiki/Club_Penguin) Disney online game for kids"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9898",
Description: `
"Tripwire (https://en.wikipedia.org/wiki/Tripwire_(software))—File Integrity Monitoring Software"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9899",
Description: `
"SCTP (https://en.wikipedia.org/wiki/Stream_Control_Transmission_Protocol) tunneling (port number used in SCTP packets encapsulated in UDP, RFC 6951 (https://tools.ietf.org/html/rfc6951))"
IANA Status - Official
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9901",
Description: `
Banana for Apache Solr
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9981",
Description: `
"Tvheadend (https://en.wikipedia.org/wiki/Tvheadend) HTTP server (web interface)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9982",
Description: `
"Tvheadend (https://en.wikipedia.org/wiki/Tvheadend) HTSP server (Streaming protocol)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9987",
Description: `
"TeamSpeak (https://en.wikipedia.org/wiki/TeamSpeak) 3 server default (voice) port (for the conflicting service see the IANA list)"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9993",
Description: `
"ZeroTier (https://en.wikipedia.org/wiki/ZeroTier) Default port for ZeroTier"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9997",
Description: `
"Splunk (https://en.wikipedia.org/wiki/Splunk) port for communication between the forwarders and indexers"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "9999",
Description: `
"Urchin (https://en.wikipedia.org/wiki/Urchin_Software_Corporation) Web Analytics"
IANA Status - Unofficial
TCP - Unspecified
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "10000",
Description: `
Network Data Management Protocol
IANA Status - Official
TCP - Yes
UDP - Yes
"BackupExec (https://en.wikipedia.org/wiki/BackupExec)"
IANA Status - Unofficial
TCP - Unspecified
UDP - Unspecified
"Webmin (https://en.wikipedia.org/wiki/Webmin), Web-based Unix/Linux system administration tool (default port)"
IANA Status - Unofficial
TCP - Unspecified
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "10000-20000",
Description: `
"Used on VoIP (https://en.wikipedia.org/wiki/Voice_over_IP) networks for receiving and transmitting voice telephony traffic which includes Google Voice (https://en.wikipedia.org/wiki/Google_Voice) via the OBiTalk (https://en.wikipedia.org/wiki/Obihai_Technology) ATA (https://en.wikipedia.org/wiki/Analog_telephone_adapter) devices as well as on the MagicJack (https://en.wikipedia.org/wiki/MagicJack) and Vonage (https://en.wikipedia.org/wiki/Vonage) ATA network devices."
IANA Status - Unofficial
TCP - No
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "10001",
Description: `
Ubiquiti UniFi access points broadcast to 255.255.255.255:10001 (UDP) to locate the controller(s)
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "10009",
Description: `
"CrossFire (https://en.wikipedia.org/wiki/CrossFire_(video_game)), a multiplayer online First Person Shooter"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "10011",
Description: `
"Teamspeak3 Chat Server"
IANA Status - Unofficial
TCP - ?
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "10024",
Description: `
"Zimbra smtp [mta]—to amavis from postfix"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "10025",
Description: `
"Zimbra smtp [mta]—back to postfix from amavis"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "10042",
Description: `
"Mathoid (https://www.mediawiki.org/wiki/Mathoid) server"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "10050",
Description: `
"Zabbix (https://en.wikipedia.org/wiki/Zabbix) agent"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "10051",
Description: `
"Zabbix (https://en.wikipedia.org/wiki/Zabbix) trapper"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "10110",
Description: `
NMEA 0183 Navigational Data. Transport of NMEA 0183 sentences over TCP or UDP
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "10172",
Description: `
"Intuit Quickbooks (https://en.wikipedia.org/wiki/Quickbooks) client"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "10200",
Description: `
"FRISK Software International (https://en.wikipedia.org/wiki/FRISK_Software_International)'s fpscand virus scanning daemon for Unix platforms"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"FRISK Software International's f-protd virus scanning daemon for Unix platforms"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "10201-10204",
Description: `
"FRISK Software International's f-protd virus scanning daemon for Unix platforms"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "10212",
Description: `
"GE Intelligent Platforms Proficy HMI/SCADA – CIMPLICITY WebView"
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "10308",
Description: `
"Lock On: Modern Air Combat (https://en.wikipedia.org/wiki/Lock_On:_Modern_Air_Combat)"
IANA Status - Unofficial
TCP - ?
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "10480",
Description: `
"SWAT 4 (https://en.wikipedia.org/wiki/SWAT_4) Dedicated Server"
IANA Status - Unofficial
TCP - ?
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "10505",
Description: `
"BlueStacks (android simulator) broadcast"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "10514",
Description: `
TLS-enabled Rsyslog (default by convention)
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "10800",
Description: `
"Touhou (https://en.wikipedia.org/wiki/Touhou) fight games (Immaterial and Missing Power (https://en.wikipedia.org/wiki/Immaterial_and_Missing_Power), Scarlet Weather Rhapsody (https://en.wikipedia.org/wiki/Scarlet_Weather_Rhapsody), Hisoutensoku (https://en.wikipedia.org/wiki/Touhou_His%C5%8Dtensoku), Hopeless Masquerade (https://en.wikipedia.org/wiki/Hopeless_Masquerade) and Urban Legend in Limbo (https://en.wikipedia.org/wiki/Urban_Legend_in_Limbo))"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "10823",
Description: `
"Farming Simulator 2011 (https://en.wikipedia.org/wiki/Farming_Simulator_2011)"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "10891",
Description: `
"Jungle Disk (this port is opened by the Jungle Disk Monitor service on the localhost)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "10933",
Description: `
"Octopus Deploy Tentacle deployment agent"
IANA Status - Official
TCP - Yes
UDP - No
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "11001",
Description: `
metasys ( Johnson Controls Metasys java AC control environment )
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "11111",
Description: `
RiCcI, Remote Configuration Interface (Redhat Linux)
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "11112",
Description: `
"ACR (https://en.wikipedia.org/wiki/American_College_of_Radiology)/NEMA (https://en.wikipedia.org/wiki/National_Electrical_Manufacturers_Association) Digital Imaging and Communications in Medicine (https://en.wikipedia.org/wiki/Digital_Imaging_and_Communications_in_Medicine) (DICOM)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "11211",
Description: `
"memcached (https://en.wikipedia.org/wiki/Memcached)"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "11214",
Description: `
memcached incoming SSL proxy
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "11215",
Description: `
memcached internal outgoing SSL proxy
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "11235",
Description: `
"Savage: Battle for Newerth (https://en.wikipedia.org/wiki/Savage:_Battle_for_Newerth)"
IANA Status - Unofficial
TCP - Unspecified
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "11311",
Description: `
"Robot Operating System (https://en.wikipedia.org/wiki/Robot_Operating_System) master"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "11371",
Description: `
"OpenPGP (https://en.wikipedia.org/wiki/OpenPGP) HTTP key server (https://en.wikipedia.org/wiki/Key_server_(cryptographic))"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "11753",
Description: `
"OpenRCT2 (https://en.wikipedia.org/wiki/OpenRCT2) multiplayer"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "12000",
Description: `
"CubeForm (/w/index.php?title=CubeForm&action=edit&redlink=1), Multiplayer SandBox Game"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "12012",
Description: `
"Audition Online Dance Battle (https://en.wikipedia.org/wiki/Audition_Online_Dance_Battle), Korea Server—Status/Version Check"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "12013",
Description: `
Audition Online Dance Battle, Korea Server
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "12035",
Description: `
"Second Life (https://en.wikipedia.org/wiki/Second_Life), used for server UDP in-bound"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "12043",
Description: `
"Second Life, used for LSL HTTPS in-bound"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "12046",
Description: `
"Second Life, used for LSL HTTP in-bound"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "12201",
Description: `
"Graylog Extended Log Format (GELF)"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "12222",
Description: `
"Light Weight Access Point Protocol (LWAPP (https://en.wikipedia.org/wiki/LWAPP)) LWAPP data (RFC 5412 (https://tools.ietf.org/html/rfc5412))"
IANA Status - Official
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "12223",
Description: `
"Light Weight Access Point Protocol (LWAPP (https://en.wikipedia.org/wiki/LWAPP)) LWAPP control (RFC 5412 (https://tools.ietf.org/html/rfc5412))"
IANA Status - Official
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "12345",
Description: `
"Cube World (https://en.wikipedia.org/wiki/Cube_World)"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
"Little Fighter 2 (https://en.wikipedia.org/wiki/Little_Fighter_2)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"NetBus (https://en.wikipedia.org/wiki/NetBus) remote administration tool (often Trojan horse (https://en.wikipedia.org/wiki/Trojan_horse_(computing)))."
IANA Status - Unofficial
TCP - Unspecified
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "12443",
Description: `
"IBM HMC (https://en.wikipedia.org/wiki/IBM_Hardware_Management_Console) web browser management access over HTTPS (https://en.wikipedia.org/wiki/HTTPS) instead of default port 443"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "12489",
Description: `
NSClient/NSClient++/NC_Net (Nagios)
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "12975",
Description: `
"LogMeIn (https://en.wikipedia.org/wiki/LogMeIn) Hamachi (https://en.wikipedia.org/wiki/Hamachi_(software)) (VPN tunnel software; also port 32976)—used to connect to Mediation Server (bibi.hamachi.cc); will attempt to use SSL (https://en.wikipedia.org/wiki/Secure_Sockets_Layer) (TCP port 443) if both 12975 & 32976 fail to connect"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "13000-13050",
Description: `
"Second Life (https://en.wikipedia.org/wiki/Second_Life), used for server UDP in-bound"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "13008",
Description: `
"CrossFire (https://en.wikipedia.org/wiki/CrossFire_(video_game)), a multiplayer online First Person Shooter"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "13075",
Description: `
"Default for BMC Software (https://en.wikipedia.org/wiki/BMC_Software) Control-M/Enterprise Manager (https://en.wikipedia.org/wiki/BMC_Control-M) Corba communication, though often changed during installation"
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "13400",
Description: `
ISO 13400 Road vehicles — Diagnostic communication over Internet Protocol(DoIP)
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "13720",
Description: `
"Symantec (https://en.wikipedia.org/wiki/NortonLifeLock) NetBackup (https://en.wikipedia.org/wiki/NetBackup)—bprd (formerly VERITAS (https://en.wikipedia.org/wiki/Veritas_Software))"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "13721",
Description: `
Symantec NetBackup—bpdbm (formerly VERITAS)
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "13724",
Description: `
Symantec Network Utility—vnetd (formerly VERITAS)
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "13782",
Description: `
Symantec NetBackup—bpcd (formerly VERITAS)
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "13783",
Description: `
Symantec VOPIED protocol (formerly VERITAS)
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "13785",
Description: `
Symantec NetBackup Database—nbdb (formerly VERITAS)
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "13786",
Description: `
Symantec nomdb (formerly VERITAS)
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "14550",
Description: `
"MAVLink (https://en.wikipedia.org/wiki/MAVLink) Ground Station Port"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "14567",
Description: `
"Battlefield 1942 (https://en.wikipedia.org/wiki/Battlefield_1942) and mods"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "14800",
Description: `
"Age of Wonders III (https://en.wikipedia.org/wiki/Age_of_Wonders_III) p2p port"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "15000",
Description: `
"psyBNC (https://en.wikipedia.org/wiki/PsyBNC)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"Wesnoth (https://en.wikipedia.org/wiki/Wesnoth)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"Kaspersky Network Agent"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
Teltonika networks remote management system (RMS)
IANA Status - Unofficial
TCP - Unspecified
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "15009",
Description: `
Teltonika networks remote management system (RMS)
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "15010",
Description: `
Teltonika networks remote management system (RMS)
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "15441",
Description: `
"ZeroNet (https://en.wikipedia.org/wiki/ZeroNet) fileserver"
IANA Status - Unofficial
TCP - ?
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "15567",
Description: `
"Battlefield Vietnam (https://en.wikipedia.org/wiki/Battlefield_Vietnam) and mods"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "15345",
Description: `
"XPilot (https://en.wikipedia.org/wiki/XPilot) Contact"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "15672",
Description: `
"RabbitMQ (https://en.wikipedia.org/wiki/RabbitMQ) management plugin"
IANA Status - Unofficial
TCP - Yes
UDP - No
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "16000",
Description: `
"Oracle WebCenter (https://en.wikipedia.org/wiki/Oracle_WebCenter) Content: Imaging (formerly known as Oracle Universal Content Management (https://en.wikipedia.org/wiki/Universal_Content_Management)). Port though often changed during installation"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"shroudBNC (https://en.wikipedia.org/wiki/ShroudBNC)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "16080",
Description: `
"Mac OS X Server (https://en.wikipedia.org/wiki/Mac_OS_X_Server) Web (HTTP) service with performance cache"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "16200",
Description: `
"Oracle WebCenter Content: Content Server (formerly known as Oracle Universal Content Management (https://en.wikipedia.org/wiki/Universal_Content_Management)). Port though often changed during installation"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "16225",
Description: `
Oracle WebCenter Content: Content Server Web UI. Port though often changed during installation
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "16250",
Description: `
"Oracle WebCenter Content: Inbound Refinery (formerly known as Oracle Universal Content Management (https://en.wikipedia.org/wiki/Universal_Content_Management)). Port though often changed during installation"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "16261",
Description: `
"Project Zomboid (https://en.wikipedia.org/wiki/Project_Zomboid) multiplayer. Additional sequential ports used for each player connecting to server."
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "16300",
Description: `
"Oracle WebCenter Content: Records Management (formerly known as Oracle Universal Records Management (/w/index.php?title=Universal_Records_Management&action=edit&redlink=1)). Port though often changed during installation"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "16384",
Description: `
CISCO Default RTP MIN
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "16384-16403",
Description: `
"Real-time Transport Protocol (https://en.wikipedia.org/wiki/Real-time_Transport_Protocol) (RTP), RTP Control Protocol (https://en.wikipedia.org/wiki/RTP_Control_Protocol) (RTCP), used by Apple (https://en.wikipedia.org/wiki/Apple_Inc.)'s iChat (https://en.wikipedia.org/wiki/IChat) for audio and video"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "16384-16387",
Description: `
"Real-time Transport Protocol (RTP), RTP Control Protocol (RTCP), used by Apple's FaceTime (https://en.wikipedia.org/wiki/FaceTime) and Game Center (https://en.wikipedia.org/wiki/Game_Center)"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "16393-16402",
Description: `
"Real-time Transport Protocol (RTP), RTP Control Protocol (RTCP), used by Apple's FaceTime and Game Center"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "16403-16472",
Description: `
"Real-time Transport Protocol (RTP), RTP Control Protocol (RTCP), used by Apple's Game Center"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "16400",
Description: `
Oracle WebCenter Content: Capture (formerly known as Oracle Document Capture). Port though often changed during installation
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "16482",
Description: `
CISCO Default RTP MAX
IANA Status - Official
TCP - Unspecified
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "16567",
Description: `
"Battlefield 2 (https://en.wikipedia.org/wiki/Battlefield_2) and mods"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "17011",
Description: `
"Worms (https://en.wikipedia.org/wiki/Worms_(series)) multiplayer"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "17224",
Description: `
"Train Realtime Data Protocol (TRDP) Process Data, network protocol used in train communication."
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "17225",
Description: `
"Train Realtime Data Protocol (TRDP) Message Data, network protocol used in train communication."
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "17333",
Description: `
CS Server (CSMS), default binary protocol port
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "17475",
Description: `
DMXControl 3 Network Broker
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "17500",
Description: `
"Dropbox (https://en.wikipedia.org/wiki/Dropbox_(storage_provider)) LanSync Protocol (db-lsp); used to synchronize file catalogs between Dropbox clients on a local network."
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "18080",
Description: `
"Monero (https://en.wikipedia.org/wiki/Monero_(cryptocurrency)) P2P network communications"
IANA Status - Unofficial
TCP - Yes
UDP - No
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "18081",
Description: `
"Monero incoming RPC calls"
IANA Status - Unofficial
TCP - Yes
UDP - No
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "18091",
Description: `
"memcached (https://en.wikipedia.org/wiki/Memcached) Internal REST HTTPS for SSL"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "18092",
Description: `
memcached Internal CAPI HTTPS for SSL
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "18104",
Description: `
RAD PDF Service
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "18200",
Description: `
"Audition Online Dance Battle (https://en.wikipedia.org/wiki/Audition_Online_Dance_Battle), AsiaSoft Thailand Server status/version check"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "18201",
Description: `
Audition Online Dance Battle, AsiaSoft Thailand Server
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "18206",
Description: `
Audition Online Dance Battle, AsiaSoft Thailand Server FAM database
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "18300",
Description: `
Audition Online Dance Battle, AsiaSoft SEA Server status/version check
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "18301",
Description: `
Audition Online Dance Battle, AsiaSoft SEA Server
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "18306",
Description: `
Audition Online Dance Battle, AsiaSoft SEA Server FAM database
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "18333",
Description: `
"Bitcoin (https://en.wikipedia.org/wiki/Bitcoin) testnet"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "18400",
Description: `
Audition Online Dance Battle, KAIZEN Brazil Server status/version check
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "18401",
Description: `
Audition Online Dance Battle, KAIZEN Brazil Server
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "18505",
Description: `
Audition Online Dance Battle R4p3 Server, Nexon Server status/version check
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "18506",
Description: `
Audition Online Dance Battle, Nexon Server
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "18605",
Description: `
"X-BEAT (https://en.wikipedia.org/wiki/X-BEAT) status/version check"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "18606",
Description: `
"X-BEAT (https://en.wikipedia.org/wiki/X-BEAT)"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "18676",
Description: `
YouView
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "19000",
Description: `
Audition Online Dance Battle, G10/alaplaya Server status/version check
IANA Status - Unofficial
TCP - Yes
UDP - Yes
"JACK (https://en.wikipedia.org/wiki/JACK_Audio_Connection_Kit) sound server"
IANA Status - Unofficial
TCP - Unspecified
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "19001",
Description: `
Audition Online Dance Battle, G10/alaplaya Server
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "19132",
Description: `
"Minecraft: Bedrock Edition (https://en.wikipedia.org/wiki/Minecraft:_Bedrock_Edition) multiplayer server"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "19133",
Description: `
"Minecraft: Bedrock Edition IPv6 multiplayer server"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "19150",
Description: `
"Gkrellm (https://en.wikipedia.org/wiki/Gkrellm) Server"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "19226",
Description: `
"Panda Software (https://en.wikipedia.org/wiki/Panda_Security) AdminSecure Communication Agent"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "19294",
Description: `
"Google Talk (https://en.wikipedia.org/wiki/Google_Talk) Voice and Video connections"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "19295",
Description: `
"Google Talk Voice and Video connections"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "19302",
Description: `
"Google Talk Voice and Video connections"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "19531",
Description: `
"systemd (https://en.wikipedia.org/wiki/Systemd)-journal-gatewayd"
IANA Status - Unofficial
TCP - Yes
UDP - No
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "19532",
Description: `
"systemd (https://en.wikipedia.org/wiki/Systemd)-journal-remote"
IANA Status - Unofficial
TCP - Yes
UDP - No
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "19812",
Description: `
"4D database SQL Communication"
IANA Status - Official
TCP - Yes
UDP - No
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "19813",
Description: `
"4D database Client Server Communication"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "19814",
Description: `
"4D database DB4D Communication"
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "19999",
Description: `
"Distributed Network Protocol—Secure (DNP (https://en.wikipedia.org/wiki/DNP3)—Secure), a secure version of the protocol used in SCADA (https://en.wikipedia.org/wiki/SCADA) systems between communicating RTU (https://en.wiktionary.org/wiki/RTU)'s and IED (https://en.wiktionary.org/wiki/IED)'s"
IANA Status - Official
TCP - Unspecified
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "20000",
Description: `
"Distributed Network Protocol (DNP (https://en.wikipedia.org/wiki/DNP3)), a protocol used in SCADA (https://en.wikipedia.org/wiki/SCADA) systems between communicating RTU (https://en.wikipedia.org/wiki/Remote_Terminal_Unit)'s and IED (https://en.wikipedia.org/wiki/Intelligent_electronic_device)'s"
IANA Status - Official
TCP - Unspecified
UDP - Unspecified
"Usermin (https://en.wikipedia.org/wiki/Usermin), Web-based Unix/Linux user administration tool (default port)"
IANA Status - Unofficial
TCP - Unspecified
UDP - Unspecified
"Used on VoIP (https://en.wikipedia.org/wiki/Voice_over_IP) networks for receiving and transmitting voice telephony traffic which includes Google Voice (https://en.wikipedia.org/wiki/Google_Voice) via the OBiTalk (https://en.wikipedia.org/wiki/Obihai_Technology) ATA (https://en.wikipedia.org/wiki/Analog_telephone_adapter) devices as well as on the MagicJack (https://en.wikipedia.org/wiki/MagicJack) and Vonage (https://en.wikipedia.org/wiki/Vonage) ATA network devices."
IANA Status - Unofficial
TCP - Unspecified
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "20560",
Description: `
"Killing Floor (https://en.wikipedia.org/wiki/Killing_Floor_(2009_video_game))"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "20582",
Description: `
HW Development IoT comms
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "20583",
Description: `
HW Development IoT comms
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "20595",
Description: `
"0 A.D. Empires Ascendant (https://en.wikipedia.org/wiki/0_A.D._(video_game))"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "20808",
Description: `
Ableton Link
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "21025",
Description: `
"Starbound Server (default), Starbound (http://playstarbound.com/)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "22000",
Description: `
"Syncthing (https://en.wikipedia.org/wiki/Syncthing) (default)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "22136",
Description: `
"FLIR Systems (http://www.flir.com/) Camera Resource Protocol"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "22222",
Description: `
"Davis Instruments, WeatherLink IP (http://davisnet.com/weather/products/weather_product.asp?pnum=06555)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "23073",
Description: `
"Soldat (https://en.wikipedia.org/wiki/Soldat_(video_game)) Dedicated Server"
IANA Status - Unofficial
TCP - Unspecified
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "23399",
Description: `
"Skype (https://en.wikipedia.org/wiki/Skype) default protocol"
IANA Status - Unofficial
TCP - Unspecified
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "23513",
Description: `
"Duke Nukem 3D source ports (/wiki/Duke_Nukem_3D#Source_ports)"
IANA Status - Unofficial
TCP - ?
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "24441",
Description: `
Pyzor spam detection network
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "24444",
Description: `
"NetBeans (https://en.wikipedia.org/wiki/NetBeans) integrated development environment"
IANA Status - Unofficial
TCP - Unspecified
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "24465",
Description: `
"Tonido Directory Server (https://en.wikipedia.org/wiki/Tonido) for Tonido (http://www.tonido.com/) which is a Personal Web App and P2P platform"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "24554",
Description: `
"BINKP (https://en.wikipedia.org/wiki/Binkp), Fidonet (https://en.wikipedia.org/wiki/Fidonet) mail transfers over TCP/IP (https://en.wikipedia.org/wiki/TCP/IP)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "24800",
Description: `
"Synergy (https://en.wikipedia.org/wiki/Synergy_(software)): keyboard/mouse sharing software"
IANA Status - Unofficial
TCP - Unspecified
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "24842",
Description: `
"StepMania: Online (https://en.wikipedia.org/wiki/StepMania): Dance Dance Revolution (https://en.wikipedia.org/wiki/Dance_Dance_Revolution) Simulator"
IANA Status - Unofficial
TCP - Unspecified
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "25565",
Description: `
"Minecraft (https://en.wikipedia.org/wiki/Minecraft) (Java Edition) multiplayer server"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"Minecraft (Java Edition) multiplayer server query"
IANA Status - Unofficial
TCP - Unspecified
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "25575",
Description: `
"Minecraft (Java Edition) multiplayer server RCON"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "25826",
Description: `
"collectd (https://en.wikipedia.org/wiki/Collectd) default port"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "26000",
Description: `
"id Software (https://en.wikipedia.org/wiki/Id_Software)'s Quake (https://en.wikipedia.org/wiki/Quake_(video_game)) server"
IANA Status - Official
TCP - Yes
UDP - Yes
"EVE Online (https://en.wikipedia.org/wiki/EVE_Online)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
"Xonotic (https://en.wikipedia.org/wiki/Xonotic), an open-source (https://en.wikipedia.org/wiki/Open-source_software) arena shooter (https://en.wikipedia.org/wiki/Arena_shooter)"
IANA Status - Unofficial
TCP - Unspecified
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "26900-26901",
Description: `
EVE Online
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "26909-26911",
Description: `
Action Tanks Online
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "27000",
Description: `
"PowerBuilder (https://en.wikipedia.org/wiki/PowerBuilder) SySAM (/w/index.php?title=SySAM&action=edit&redlink=1) license server"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "27000-27006",
Description: `
"id Software (https://en.wikipedia.org/wiki/Id_Software)'s QuakeWorld (https://en.wikipedia.org/wiki/QuakeWorld) master server"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "27000-27009",
Description: `
"FlexNet Publisher (https://en.wikipedia.org/wiki/FlexNet_Publisher)'s License server (from the range of default ports)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "27000-27015",
Description: `
"Steam (https://en.wikipedia.org/wiki/Steam_(software)) (game client traffic)"
IANA Status - Unofficial
TCP - No
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "27015",
Description: `
"GoldSrc (https://en.wikipedia.org/wiki/GoldSrc) and Source engine (https://en.wikipedia.org/wiki/Source_engine) dedicated server port"
IANA Status - Unofficial
TCP - No
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "27015-27018",
Description: `
"Unturned (https://en.wikipedia.org/wiki/Unturned), a survival game"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "27015-27030",
Description: `
"Steam (matchmaking and HLTV)"
IANA Status - Unofficial
TCP - No
UDP - Yes
"Steam (downloads)"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "27016",
Description: `
"Magicka (https://en.wikipedia.org/wiki/Magicka) server port"
IANA Status - Unofficial
TCP - Unspecified
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "27017",
Description: `
"MongoDB (https://en.wikipedia.org/wiki/MongoDB) daemon process (mongod) and routing service (mongos)"
IANA Status - Unofficial
TCP - Yes
UDP - No
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "27031",
Description: `
"Steam (In-Home Streaming)"
IANA Status - Unofficial
TCP - Ports 27036 & 27037
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "27036",
Description: `
"Steam (In-Home Streaming)"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "27037",
Description: `
"Steam (In-Home Streaming)"
IANA Status - Unofficial
TCP - Yes
UDP - Ports 27031 & 27036
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "27374",
Description: `
"Sub7 (https://en.wikipedia.org/wiki/Sub7) default."
IANA Status - Unofficial
TCP - Unspecified
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "27500-27900",
Description: `
"id Software (https://en.wikipedia.org/wiki/Id_Software)'s QuakeWorld (https://en.wikipedia.org/wiki/QuakeWorld)"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "27888",
Description: `
"Kaillera (https://en.wikipedia.org/wiki/Kaillera) server"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "27901-27910",
Description: `
"id Software (https://en.wikipedia.org/wiki/Id_Software)'s Quake II (https://en.wikipedia.org/wiki/Quake_II) master server"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "27950",
Description: `
"OpenArena (https://en.wikipedia.org/wiki/OpenArena) outgoing"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "27960-27969",
Description: `
"Activision (https://en.wikipedia.org/wiki/Activision)'s Enemy Territory (https://en.wikipedia.org/wiki/Wolfenstein:_Enemy_Territory) and id Software (https://en.wikipedia.org/wiki/Id_Software)'s Quake III Arena (https://en.wikipedia.org/wiki/Quake_III_Arena), Quake III and Quake Live (https://en.wikipedia.org/wiki/Quake_Live) and some ioquake3 derived games, such as Urban Terror (OpenArena incoming)"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "28001",
Description: `
"Starsiege: Tribes (https://en.wikipedia.org/wiki/Starsiege:_Tribes)"
IANA Status - Unofficial
TCP - Unspecified
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "28015",
Description: `
"Rust (video game) (https://en.wikipedia.org/wiki/wiki/Rust_(video_game))"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "28016",
Description: `
"Rust RCON (video game)"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "28770-28771",
Description: `
"AssaultCube Reloaded (/w/index.php?title=AssaultCube_Reloaded&action=edit&redlink=1), a video game based upon a modification of AssaultCube (https://en.wikipedia.org/wiki/AssaultCube)"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "28785-28786",
Description: `
"Cube 2: Sauerbraten (https://en.wikipedia.org/wiki/Cube_2:_Sauerbraten)"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "28852",
Description: `
"Killing Floor (https://en.wikipedia.org/wiki/Killing_Floor_(2009_video_game))"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "28910",
Description: `
"Nintendo Wi-Fi Connection (https://en.wikipedia.org/wiki/Nintendo_Wi-Fi_Connection)"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "28960",
Description: `
"Call of Duty (https://en.wikipedia.org/wiki/Call_of_Duty); Call of Duty: United Offensive (https://en.wikipedia.org/wiki/Call_of_Duty:_United_Offensive); Call of Duty 2 (https://en.wikipedia.org/wiki/Call_of_Duty_2); Call of Duty 4: Modern Warfare (https://en.wikipedia.org/wiki/Call_of_Duty_4:_Modern_Warfare); Call of Duty: World at War (https://en.wikipedia.org/wiki/Call_of_Duty:_World_at_War) (PC platform)"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "29000",
Description: `
"Perfect World (https://en.wikipedia.org/wiki/Perfect_World_(video_game)), an adventure and fantasy MMORPG (https://en.wikipedia.org/wiki/MMORPG)"
IANA Status - Unofficial
TCP - ?
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "29070",
Description: `
"Jedi Knight: Jedi Academy (https://en.wikipedia.org/wiki/Jedi_Knight:_Jedi_Academy) by Ravensoft (https://en.wikipedia.org/wiki/Ravensoft)"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "29900-29901",
Description: `
"Nintendo Wi-Fi Connection"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "29920",
Description: `
"Nintendo Wi-Fi Connection"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "30000",
Description: `
"XLink Kai P2P (https://en.wikipedia.org/wiki/XLink_Kai)"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "30033",
Description: `
"Teamspeak3 Chat Server"
IANA Status - Unofficial
TCP - ?
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "30564",
Description: `
"Multiplicity (https://en.wikipedia.org/wiki/Multiplicity_(software)): keyboard/mouse/clipboard sharing software"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "31337",
Description: `
"Back Orifice (https://en.wikipedia.org/wiki/Back_Orifice) and Back Orifice 2000 (https://en.wikipedia.org/wiki/Back_Orifice_2000) remote administration tools"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "31416",
Description: `
"BOINC (https://en.wikipedia.org/wiki/BOINC) RPC (https://en.wikipedia.org/wiki/Remote_procedure_call)"
IANA Status - Unofficial
TCP - ?
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "31438",
Description: `
"Rocket U2 (https://en.wikipedia.org/wiki/Rocket_U2)"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "31457",
Description: `
"TetriNET (https://en.wikipedia.org/wiki/TetriNET)"
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "32137",
Description: `
"Immunet Protect (https://en.wikipedia.org/wiki/Immunet) (UDP in version 2.0, TCP since version 3.0)"
IANA Status - Unofficial
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "32400",
Description: `
"Plex Media Server (https://en.wikipedia.org/wiki/Plex_Media_Server)"
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "32764",
Description: `
"A backdoor (https://en.wikipedia.org/wiki/Backdoor_(computing)) found on certain Linksys, Netgear and other wireless DSL modems/combination routers"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "32887",
Description: `
"Ace of Spades (https://en.wikipedia.org/wiki/Ace_of_Spades_(video_game)), a multiplayer FPS (https://en.wikipedia.org/wiki/First-person_shooter) video game"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "32976",
Description: `
"LogMeIn Hamachi (https://en.wikipedia.org/wiki/LogMeIn_Hamachi), a VPN (https://en.wikipedia.org/wiki/Virtual_private_network) application; also TCP port 12975 and SSL (https://en.wikipedia.org/wiki/Secure_Sockets_Layer) (TCP 443)."
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "33434",
Description: `
"traceroute (https://en.wikipedia.org/wiki/Traceroute)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "33848",
Description: `
"Jenkins (https://en.wikipedia.org/wiki/Jenkins_(software)), a continuous integration (https://en.wikipedia.org/wiki/Continuous_integration) (CI) tool"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "34000",
Description: `
"Infestation: Survivor Stories (https://en.wikipedia.org/wiki/Infestation:_Survivor_Stories) (formerly known as The War Z), a multiplayer zombie video game"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "34197",
Description: `
"Factorio (https://en.wikipedia.org/wiki/Factorio), a multiplayer survival and factory-building game"
IANA Status - Unofficial
TCP - No
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "35357",
Description: `
"OpenStack Identity (https://en.wikipedia.org/wiki/OpenStack#Identity_(Keystone)) (Keystone) administration"
IANA Status - Official
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "37008",
Description: `
"TZSP (https://en.wikipedia.org/wiki/TZSP) intrusion detection"
IANA Status - Unofficial
TCP - Unspecified
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "40000",
Description: `
"SafetyNET p (https://en.wikipedia.org/wiki/SafetyNET_p) – a real-time Industrial Ethernet (https://en.wikipedia.org/wiki/Industrial_Ethernet) protocol"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "41121",
Description: `
"Tentacle Server - Pandora FMS (https://en.wikipedia.org/wiki/Pandora_FMS)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "41794",
Description: `
"Crestron Control Port - Crestron Electronics (https://en.wikipedia.org/wiki/Crestron_Electronics)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "41795",
Description: `
"Crestron Terminal Port - Crestron Electronics (https://en.wikipedia.org/wiki/Crestron_Electronics)"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "41796",
Description: `
"Crestron Secure Control Port - Crestron Electronics (https://en.wikipedia.org/wiki/Crestron_Electronics)"
IANA Status - Official
TCP - Yes
UDP - No
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "41797",
Description: `
"Crestron Secure Terminal Port - Crestron Electronics (https://en.wikipedia.org/wiki/Crestron_Electronics)"
IANA Status - Official
TCP - Yes
UDP - No
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "43110",
Description: `
"ZeroNet (https://en.wikipedia.org/wiki/ZeroNet) web UI default port"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "43594-43595",
Description: `
"RuneScape (https://en.wikipedia.org/wiki/RuneScape)"
IANA Status - Unofficial
TCP - ?
UDP - ?
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "44405",
Description: `
"Mu Online (https://en.wikipedia.org/wiki/Mu_Online) Connect Server"
IANA Status - Unofficial
TCP - Yes
UDP - Unspecified
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "44818",
Description: `
"EtherNet/IP (https://en.wikipedia.org/wiki/EtherNet/IP) explicit messaging"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "47808-47823",
Description: `
"BACnet (https://en.wikipedia.org/wiki/BACnet) Building Automation and Control Networks"
IANA Status - Official
TCP - Yes
UDP - Yes
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
{
Name: "49151",
Description: `
"Reserved"
IANA Status - Official
TCP - Reserved
UDP - Reserved
https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Registered_ports`,
},
} | registered-ports.go | 0.680985 | 0.543469 | registered-ports.go | starcoder |
package graph
import (
i04eb5309aeaafadd28374d79c8471df9b267510b4dc2e3144c378c50f6fd7b55 "github.com/microsoft/kiota/abstractions/go/serialization"
)
// Hashes
type Hashes struct {
// Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.
additionalData map[string]interface{};
// The CRC32 value of the file in little endian (if available). Read-only.
crc32Hash *string;
// A proprietary hash of the file that can be used to determine if the contents of the file have changed (if available). Read-only.
quickXorHash *string;
// SHA1 hash for the contents of the file (if available). Read-only.
sha1Hash *string;
// SHA256 hash for the contents of the file (if available). Read-only.
sha256Hash *string;
}
// NewHashes instantiates a new hashes and sets the default values.
func NewHashes()(*Hashes) {
m := &Hashes{
}
m.SetAdditionalData(make(map[string]interface{}));
return m
}
// GetAdditionalData gets the additionalData property value. Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.
func (m *Hashes) GetAdditionalData()(map[string]interface{}) {
if m == nil {
return nil
} else {
return m.additionalData
}
}
// GetCrc32Hash gets the crc32Hash property value. The CRC32 value of the file in little endian (if available). Read-only.
func (m *Hashes) GetCrc32Hash()(*string) {
if m == nil {
return nil
} else {
return m.crc32Hash
}
}
// GetQuickXorHash gets the quickXorHash property value. A proprietary hash of the file that can be used to determine if the contents of the file have changed (if available). Read-only.
func (m *Hashes) GetQuickXorHash()(*string) {
if m == nil {
return nil
} else {
return m.quickXorHash
}
}
// GetSha1Hash gets the sha1Hash property value. SHA1 hash for the contents of the file (if available). Read-only.
func (m *Hashes) GetSha1Hash()(*string) {
if m == nil {
return nil
} else {
return m.sha1Hash
}
}
// GetSha256Hash gets the sha256Hash property value. SHA256 hash for the contents of the file (if available). Read-only.
func (m *Hashes) GetSha256Hash()(*string) {
if m == nil {
return nil
} else {
return m.sha256Hash
}
}
// GetFieldDeserializers the deserialization information for the current model
func (m *Hashes) GetFieldDeserializers()(map[string]func(interface{}, i04eb5309aeaafadd28374d79c8471df9b267510b4dc2e3144c378c50f6fd7b55.ParseNode)(error)) {
res := make(map[string]func(interface{}, i04eb5309aeaafadd28374d79c8471df9b267510b4dc2e3144c378c50f6fd7b55.ParseNode)(error))
res["crc32Hash"] = func (o interface{}, n i04eb5309aeaafadd28374d79c8471df9b267510b4dc2e3144c378c50f6fd7b55.ParseNode) error {
val, err := n.GetStringValue()
if err != nil {
return err
}
if val != nil {
m.SetCrc32Hash(val)
}
return nil
}
res["quickXorHash"] = func (o interface{}, n i04eb5309aeaafadd28374d79c8471df9b267510b4dc2e3144c378c50f6fd7b55.ParseNode) error {
val, err := n.GetStringValue()
if err != nil {
return err
}
if val != nil {
m.SetQuickXorHash(val)
}
return nil
}
res["sha1Hash"] = func (o interface{}, n i04eb5309aeaafadd28374d79c8471df9b267510b4dc2e3144c378c50f6fd7b55.ParseNode) error {
val, err := n.GetStringValue()
if err != nil {
return err
}
if val != nil {
m.SetSha1Hash(val)
}
return nil
}
res["sha256Hash"] = func (o interface{}, n i04eb5309aeaafadd28374d79c8471df9b267510b4dc2e3144c378c50f6fd7b55.ParseNode) error {
val, err := n.GetStringValue()
if err != nil {
return err
}
if val != nil {
m.SetSha256Hash(val)
}
return nil
}
return res
}
func (m *Hashes) IsNil()(bool) {
return m == nil
}
// Serialize serializes information the current object
func (m *Hashes) Serialize(writer i04eb5309aeaafadd28374d79c8471df9b267510b4dc2e3144c378c50f6fd7b55.SerializationWriter)(error) {
{
err := writer.WriteStringValue("crc32Hash", m.GetCrc32Hash())
if err != nil {
return err
}
}
{
err := writer.WriteStringValue("quickXorHash", m.GetQuickXorHash())
if err != nil {
return err
}
}
{
err := writer.WriteStringValue("sha1Hash", m.GetSha1Hash())
if err != nil {
return err
}
}
{
err := writer.WriteStringValue("sha256Hash", m.GetSha256Hash())
if err != nil {
return err
}
}
{
err := writer.WriteAdditionalData(m.GetAdditionalData())
if err != nil {
return err
}
}
return nil
}
// SetAdditionalData sets the additionalData property value. Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.
func (m *Hashes) SetAdditionalData(value map[string]interface{})() {
if m != nil {
m.additionalData = value
}
}
// SetCrc32Hash sets the crc32Hash property value. The CRC32 value of the file in little endian (if available). Read-only.
func (m *Hashes) SetCrc32Hash(value *string)() {
if m != nil {
m.crc32Hash = value
}
}
// SetQuickXorHash sets the quickXorHash property value. A proprietary hash of the file that can be used to determine if the contents of the file have changed (if available). Read-only.
func (m *Hashes) SetQuickXorHash(value *string)() {
if m != nil {
m.quickXorHash = value
}
}
// SetSha1Hash sets the sha1Hash property value. SHA1 hash for the contents of the file (if available). Read-only.
func (m *Hashes) SetSha1Hash(value *string)() {
if m != nil {
m.sha1Hash = value
}
}
// SetSha256Hash sets the sha256Hash property value. SHA256 hash for the contents of the file (if available). Read-only.
func (m *Hashes) SetSha256Hash(value *string)() {
if m != nil {
m.sha256Hash = value
}
} | models/microsoft/graph/hashes.go | 0.626238 | 0.421552 | hashes.go | starcoder |
package heap
// Heap is a struct which wraps the slice of provided type and internally
// maintains integrity of heap datastructure.
type Heap[T any] struct {
queue []T
less func(left, right T) bool
setIndex func(e T, i int)
}
// NewHeap converts provided slice into a heap. The queue provided
// should not be used after being introduced to NewHeap.
func NewHeap[T any](queue []T, less func(left, right T) bool, setIndex func(e T, i int)) *Heap[T] {
h := &Heap[T]{
queue: queue,
less: less,
setIndex: setIndex,
}
h.init()
return h
}
// Size returns number of elements in the queue.
func (h *Heap[T]) Size() int {
return len(h.queue)
}
// Peek returns smallest element defined by h.less while still maintaining them in queue.
func (h *Heap[T]) Peek() T {
return h.queue[0]
}
// Push pushes the element x onto the heap.
// The complexity is O(log n) where n = h.Size().
func (h *Heap[T]) Push(x T) {
h.queue = append(h.queue, x)
n := h.Size() - 1
h.setIndex(x, n)
h.up(h.Size() - 1)
}
// Pop removes and returns the minimum element (according to h.less) from the heap.
// The complexity is O(log n) where n = h.Size().
// Pop is equivalent to Remove(h, 0).
func (h *Heap[T]) Pop() T {
n := h.Size() - 1
h.swap(0, n)
h.down(0, n)
x := h.queue[n]
h.queue = h.queue[0:n]
return x
}
// Remove removes and returns the element at index i from the heap.
// The complexity is O(log n) where n = h.Size().
func (h *Heap[T]) Remove(i int) T {
n := h.Size() - 1
if n != i {
h.swap(i, n)
if !h.down(i, n) {
h.up(i)
}
}
x := h.queue[n]
h.queue = h.queue[0:n]
return x
}
// Fix re-establishes the heap ordering after the element at index i has changed its value.
// Changing the value of the element at index i and then calling Fix is equivalent to,
// but less expensive than, calling Remove(h, i) followed by a Push of the new value.
// The complexity is O(log n) where n = h.Size().
func (h *Heap[T]) Fix(i int) {
if !h.down(i, h.Size()) {
h.up(i)
}
}
// Init establishes the heap invariants required by the other routines in this package.
// Init is idempotent with respect to the heap invariants
// and may be called whenever the heap invariants may have been invalidated.
// The complexity is O(n) where n = h.Size().
func (h *Heap[T]) init() {
// heapify
n := h.Size()
for i := n/2 - 1; i >= 0; i-- {
h.down(i, n)
}
}
func (h *Heap[T]) swap(i, j int) {
h.queue[i], h.queue[j] = h.queue[j], h.queue[i]
h.setIndex(h.queue[i], i)
h.setIndex(h.queue[j], j)
}
func (h *Heap[T]) up(j int) {
for {
i := (j - 1) / 2 // parent
if i == j || !h.less(h.queue[j], h.queue[i]) {
break
}
h.swap(i, j)
j = i
}
}
func (h *Heap[T]) down(i0, n int) bool {
i := i0
for {
j1 := 2*i + 1
if j1 >= n || j1 < 0 { // j1 < 0 after int overflow
break
}
j := j1 // left child
if j2 := j1 + 1; j2 < n && h.less(h.queue[j2], h.queue[j1]) {
j = j2 // = 2*i + 2 // right child
}
if !h.less(h.queue[j], h.queue[i]) {
break
}
h.swap(i, j)
i = j
}
return i > i0
} | heap/heap.go | 0.773259 | 0.449634 | heap.go | starcoder |
package psi
func PointerField(psi []byte) uint8 {
return psi[0]
}
// TableID returns the psi table header table id
func TableID(psi []byte) uint8 {
return tableID(psi[1+PointerField(psi):])
}
// SectionSyntaxIndicator returns true if the psi contains section syntax
func SectionSyntaxIndicator(psi []byte) bool {
return sectionSyntaxIndicator(psi[1+PointerField(psi):])
}
// PrivateIndicator returns true if the psi contains private data
func PrivateIndicator(psi []byte) bool {
return psi[2+PointerField(psi)]&0x40 != 0
}
// SectionLength returns the psi section length
func SectionLength(psi []byte) uint16 {
return sectionLength(psi[1+PointerField(psi):])
}
// tableID returns the table id from the header of a section
func tableID(psi []byte) uint8 {
return uint8(psi[0])
}
func sectionSyntaxIndicator(psi []byte) bool {
return psi[1]&0x80 != 0
}
// sectionLength returns the length of a single psi section
func sectionLength(psi []byte) uint16 {
return uint16(psi[1]&3)<<8 | uint16(psi[2])
}
// NewPointerField will return a new pointer field with stuffing as raw bytes.
// The pointer field specifies where the TableHeader should start.
// Everything in between the pointer field and table header should
// be bytes with the value 0xFF.
func NewPointerField(size int) []byte {
data := make([]byte, size+1)
data[0] = byte(size)
for i := 1; i < size+1; i++ {
data[i] = 0xFF
}
return data
}
// PSIFromBytes returns the PSI struct from a byte slice
func TableHeaderFromBytes(data []byte) TableHeader {
th := TableHeader{}
th.TableID = data[0]
th.SectionSyntaxIndicator = data[1]&0x80 != 0
th.PrivateIndicator = data[1]&0x40 != 0
th.SectionLength = uint16(data[1]&0x03 /* 0000 0011 */)<<8 | uint16(data[2])
return th
}
// Data returns the byte representation of the PSI struct.
func (th TableHeader) Data() []byte {
data := make([]byte, 3)
data[0] = th.TableID
if th.SectionSyntaxIndicator {
data[1] |= 0x80
}
if th.PrivateIndicator {
data[1] |= 0x40
}
// set reserved bits to 11
data[1] |= 0x30 // 0011 0000
data[1] |= byte(th.SectionLength>>8) & 0x03 // 0000 0011
data[2] = byte(th.SectionLength)
return data
}
// NewPSI will create a PSI with default values of zero and false for everything
func NewTableHeader() TableHeader {
return TableHeader{}
} | psi/psi.go | 0.756268 | 0.414129 | psi.go | starcoder |
package layers
import (
"fmt"
"github.com/aunum/log"
g "gorgonia.org/gorgonia"
t "gorgonia.org/tensor"
)
// FC is a fully connected layer of neurons.
type FC struct {
// Input is the number of units in input.
Input int
// Output is the number of units in the output.
Output int
// Name of the layer.
Name string
activation Activation
weights *g.Node
init g.InitWFn
dtype t.Dtype
bias *g.Node
useBias bool
biasInit g.InitWFn
isBatched bool
shared *FC
}
// FCOpts are options for a fully connected layer.
type FCOpts func(*FC)
// NewFC returns a new fully connected layer.
func NewFC(input, output int, opts ...FCOpts) *FC {
fc := &FC{
Input: input,
Output: output,
dtype: g.Float32,
init: g.GlorotU(1.0),
useBias: true,
biasInit: g.Zeroes(),
}
for _, opt := range opts {
opt(fc)
}
return fc
}
// WithActivation adds an activation function to the layer.
func WithActivation(fn Activation) func(*FC) {
return func(f *FC) {
f.activation = fn
}
}
// WithName gives a name to this layer.
func WithName(name string) func(*FC) {
return func(f *FC) {
f.Name = name
}
}
// WithInit adds an init function to the weights.
// Defaults to Glorot.
func WithInit(fn g.InitWFn) func(*FC) {
return func(f *FC) {
f.init = fn
}
}
// WithType sets the type for the layer
// Defaults to Float32.
func WithType(dtype t.Dtype) func(*FC) {
return func(f *FC) {
f.dtype = dtype
}
}
// WithBiasInit adds an init function to the bias.
// Defaults to zeros.
func WithBiasInit(fn g.InitWFn) func(*FC) {
return func(f *FC) {
f.init = fn
}
}
// WithNoBias removes the bias.
func WithNoBias() func(*FC) {
return func(f *FC) {
f.useBias = false
}
}
// Compile the layer into the graph.
func (f *FC) Compile(graph *g.ExprGraph, opts ...LayerOpt) {
for _, opt := range opts {
opt(f)
}
if f.shared != nil {
f.weights = g.NewMatrix(graph, f.dtype, g.WithShape(f.Input, f.Output), g.WithName(f.Name), g.WithValue(f.shared.weights.Value()))
if f.useBias {
f.bias = g.NewMatrix(graph, f.dtype, g.WithShape(1, f.Output), g.WithName(fmt.Sprintf("%s-bias", f.Name)), g.WithValue(f.shared.bias.Value()))
}
return
}
f.weights = g.NewMatrix(graph, f.dtype, g.WithShape(f.Input, f.Output), g.WithInit(f.init), g.WithName(f.Name))
if f.useBias {
f.bias = g.NewMatrix(graph, f.dtype, g.WithShape(1, f.Output), g.WithInit(f.biasInit), g.WithName(fmt.Sprintf("%s-bias", f.Name)))
}
}
// Fwd is a forward pass on a single fully connected layer.
func (f *FC) Fwd(x *g.Node) (*g.Node, error) {
var xw, xwb *g.Node
var err error
if x.IsVector() {
s := t.Shape{1}
s = append(s, x.Shape()...)
x, err = g.Reshape(x, s)
if err != nil {
return nil, err
}
log.Debugf("normalizing dimensions of x to %v", s)
}
// Note: parts of this are borrowed from https://github.com/gorgonia/golgi
if xw, err = g.Mul(x, f.weights); err != nil {
return nil, err
}
if f.bias == nil {
xwb = xw
goto act
}
if f.isBatched {
if xwb, err = g.BroadcastAdd(xw, f.bias, nil, []byte{0}); err != nil {
return nil, err
}
} else {
if xwb, err = g.Add(xw, f.bias); err != nil {
return nil, err
}
}
act:
if f.activation == nil {
return xwb, nil
}
a, err := f.activation.Fwd(xwb)
if err != nil {
return nil, err
}
return a, err
}
// Learnables are the learnable parameters of the fully connected layer.
func (f *FC) Learnables() g.Nodes {
if f.bias != nil {
return g.Nodes{f.weights, f.bias}
}
return g.Nodes{f.weights}
}
// Clone the layer without any nodes. (nodes cannot be shared)
func (f *FC) Clone() Layer {
return &FC{
Input: f.Input,
Output: f.Output,
Name: f.Name,
activation: f.activation.Clone(),
init: f.init,
dtype: f.dtype,
useBias: f.useBias,
biasInit: f.biasInit,
isBatched: f.isBatched,
}
}
// Graph returns the graph this layer was compiled with.
func (f *FC) Graph() *g.ExprGraph {
if f.weights == nil {
return nil
}
return f.weights.Graph()
} | vendor/github.com/aunum/gold/pkg/v1/model/layers/fc.go | 0.757256 | 0.494751 | fc.go | starcoder |
package cvss2
import "fmt"
type BaseMetrics struct {
AccessVector
AccessComplexity
Authentication
ConfidentialityImpact
IntegrityImpact
AvailabilityImpact
}
type AccessVector int
const (
AccessVectorLocal AccessVector = iota + 1
AccessVectorAdjecentNetwork
AccessVectorNetwork
)
var (
weightsAccessVector = []float64{0, 0.395, 0.646, 1}
codeAccessVector = []string{"", "L", "A", "N"}
)
func (av AccessVector) defined() bool {
return int(av) != 0
}
func (av AccessVector) weight() float64 {
return weightsAccessVector[av]
}
func (av AccessVector) String() string {
return codeAccessVector[av]
}
func (av *AccessVector) parse(str string) error {
idx, found := findIndex(str, codeAccessVector)
if found {
*av = AccessVector(idx)
return nil
}
return fmt.Errorf("illegal access vector code %s", str)
}
type AccessComplexity int
const (
AccessComplexityHigh AccessComplexity = iota + 1
AccessComplexityMedium
AccessComplexityLow
)
var (
weightsAccessComplexity = []float64{0, 0.35, 0.61, 0.71}
codeAccessComplexity = []string{"", "H", "M", "L"}
)
func (ac AccessComplexity) defined() bool {
return int(ac) != 0
}
func (ac AccessComplexity) weight() float64 {
return weightsAccessComplexity[ac]
}
func (ac AccessComplexity) String() string {
return codeAccessComplexity[ac]
}
func (ac *AccessComplexity) parse(str string) error {
idx, found := findIndex(str, codeAccessComplexity)
if found {
*ac = AccessComplexity(idx)
return nil
}
return fmt.Errorf("illegal access complexity code %s", str)
}
type Authentication int
const (
AuthenticationMultiple Authentication = iota + 1
AuthenticationSingle
AuthenticationNone
)
var (
weightsAuthentication = []float64{0, 0.45, 0.56, 0.704}
codeAuthentication = []string{"", "M", "S", "N"}
)
func (au Authentication) defined() bool {
return int(au) != 0
}
func (au Authentication) weight() float64 {
return weightsAuthentication[au]
}
func (au Authentication) String() string {
return codeAuthentication[au]
}
func (au *Authentication) parse(str string) error {
idx, found := findIndex(str, codeAuthentication)
if found {
*au = Authentication(idx)
return nil
}
return fmt.Errorf("illegal authentication code %s", str)
}
type ConfidentialityImpact int
const (
ConfidentialityImpactNone ConfidentialityImpact = iota + 1
ConfidentialityImpactPartial
ConfidentialityImpactComplete
)
var (
weightsConfidentialityImpact = []float64{0, 0, 0.275, 0.66}
codeConfidentialityImpact = []string{"", "N", "P", "C"}
)
func (ci ConfidentialityImpact) defined() bool {
return int(ci) != 0
}
func (ci ConfidentialityImpact) weight() float64 {
return weightsConfidentialityImpact[ci]
}
func (ci ConfidentialityImpact) String() string {
return codeConfidentialityImpact[ci]
}
func (ci *ConfidentialityImpact) parse(str string) error {
idx, found := findIndex(str, codeConfidentialityImpact)
if found {
*ci = ConfidentialityImpact(idx)
return nil
}
return fmt.Errorf("illegal confidentiality impact %s", str)
}
type IntegrityImpact int
const (
IntegerityImpactNone IntegrityImpact = iota + 1
IntegrityImpactPartial
IntegrityImpactComplete
)
var (
weightsIntegrityImpact = []float64{0, 0, 0.275, 0.66}
codeIntegrityImpact = []string{"", "N", "P", "C"}
)
func (ii IntegrityImpact) defined() bool {
return int(ii) != 0
}
func (ii IntegrityImpact) weight() float64 {
return weightsIntegrityImpact[ii]
}
func (ii IntegrityImpact) String() string {
return codeIntegrityImpact[ii]
}
func (ii *IntegrityImpact) parse(str string) error {
idx, found := findIndex(str, codeIntegrityImpact)
if found {
*ii = IntegrityImpact(idx)
return nil
}
return fmt.Errorf("illegal integrity impact code %s", str)
}
type AvailabilityImpact int
const (
AvailabilityImpactNone AvailabilityImpact = iota + 1
AvailabilityImpactPartial
AvailabilityImpactComplete
)
var (
weightsAvailabilityImpact = []float64{0, 0, 0.275, 0.66}
codeAvailabilityImpact = []string{"", "N", "P", "C"}
)
func (ai AvailabilityImpact) defined() bool {
return int(ai) != 0
}
func (ai AvailabilityImpact) weight() float64 {
return weightsAvailabilityImpact[ai]
}
func (ai AvailabilityImpact) String() string {
return codeAvailabilityImpact[ai]
}
func (ai *AvailabilityImpact) parse(str string) error {
idx, found := findIndex(str, codeAvailabilityImpact)
if found {
*ai = AvailabilityImpact(idx)
return nil
}
return fmt.Errorf("illegal availability impact code %s", str)
} | cvss2/base_metrics.go | 0.673084 | 0.432303 | base_metrics.go | starcoder |
package complex
import (
"sort"
"gioui.org/widget"
"currents/pkg/audio"
)
type gradientData struct {
name string
gradient audio.Gradient
// Button to select the gradient in the editor list
selectBtn widget.Clickable
// Picker buttons to display each colour at each position
// and shows a color picker to change the colour specified
pickerBtns []widget.Clickable
// Sliders to change the position of the given colour
positions []widget.Float
// Buttons to remove the specified colour from the gradient
removeBtns []widget.Clickable
}
func newGradientData(name string, gradient audio.Gradient) *gradientData {
d := &gradientData{
name: name,
gradient: gradient,
pickerBtns: make([]widget.Clickable, len(gradient)),
positions: make([]widget.Float, len(gradient)),
removeBtns: make([]widget.Clickable, len(gradient)),
}
for i := range d.positions {
d.positions[i].Value = float32(d.gradient[i].Pos)
}
return d
}
func (gd *gradientData) Sort() {
posSort := func(i, j int) bool {
return gd.gradient[i].Pos < gd.gradient[j].Pos
}
sort.Slice(gd.pickerBtns, posSort)
sort.Slice(gd.positions, posSort)
sort.Slice(gd.removeBtns, posSort)
sort.Slice(gd.gradient, posSort)
}
func (gd *gradientData) RemoveColour(index int) {
a := make(audio.Gradient, 0)
a = append(a, gd.gradient[:index]...)
gd.gradient = append(a, gd.gradient[index+1:]...)
b := make([]widget.Clickable, 0)
b = append(b, gd.pickerBtns[:index]...)
gd.pickerBtns = append(b, gd.pickerBtns[index+1:]...)
c := make([]widget.Float, 0)
c = append(c, gd.positions[:index]...)
gd.positions = append(c, gd.positions[index+1:]...)
d := make([]widget.Clickable, 0)
d = append(d, gd.removeBtns[:index]...)
gd.removeBtns = append(d, gd.removeBtns[index+1:]...)
}
func (gd *gradientData) AddColour() {
gd.gradient = append(gd.gradient, audio.DefaultGradient()...)
gd.pickerBtns = append(gd.pickerBtns, widget.Clickable{})
gd.positions = append(gd.positions, widget.Float{Value: 1.0})
gd.removeBtns = append(gd.removeBtns, widget.Clickable{})
} | pkg/gui/complex/gradient_data.go | 0.567098 | 0.484319 | gradient_data.go | starcoder |
package interestvalue
import (
"fmt"
"math"
"github.com/pkg/errors"
)
// CalculateDelta calculations for all banks
func (cireq CreateInterestRequest) CalculateDelta() (CreateInterestResponse, error) {
bks, delta, err := cireq.computeBanksDelta()
if err != nil {
return CreateInterestResponse{}, err
}
ciresp := CreateInterestResponse{
Banks: bks,
Delta: roundToNearest(delta),
}
return ciresp, nil
}
func (cireq CreateInterestRequest) computeBanksDelta() ([]Bank, float64, error) {
var bks []Bank
var delta float64
for _, nb := range cireq.NewBanks {
ds, bDelta, err := nb.computeBankDelta()
if err != nil {
return nil, 0, err
}
bk := Bank{
Name: nb.Name,
Deposits: ds,
Delta: roundToNearest(bDelta),
}
bks = append(bks, bk)
delta = delta + bk.Delta
}
return bks, delta, nil
}
func (nb NewBank) computeBankDelta() ([]Deposit, float64, error) {
var ds []Deposit
var bDelta float64
for _, nd := range nb.NewDeposits {
d := Deposit{
Account: nd.Account,
AccountType: nd.AccountType,
APY: nd.APY,
Years: nd.Years,
Amount: nd.Amount,
}
err := d.computeDepositDelta()
if err != nil {
return nil, 0, err
}
ds = append(ds, d)
bDelta = bDelta + d.Delta
}
return ds, bDelta, nil
}
// CalculateDelta calculates interest for 30 days for output/response Deposit
func (d *Deposit) computeDepositDelta() error {
e := d.earned()
e30Days, err := earned30days(e, d.Years)
if err != nil {
return errors.Wrapf(err, "calculation for Account: %s", d.Account)
}
d.Delta = roundToNearest(e30Days)
return nil
}
func (d *Deposit) earned() float64 {
switch d.AccountType {
case Sa, CD:
return compoundInterest(d.APY, d.Years, d.Amount)
case Br:
return simpleInterest(d.APY, d.Years, d.Amount)
default:
return 0.0
}
}
func roundToNearest(n float64) float64 {
return math.Round(n*100) / 100
}
func simpleInterest(apy float64, years float64, amount float64) float64 {
rateInDecimal := apy / 100
intEarned := amount * rateInDecimal * years
return intEarned
}
func compoundInterest(apy float64, years float64, amount float64) float64 {
rateInDecimal := apy / 100
calInProcess := math.Pow(1+rateInDecimal, years)
intEarned := amount*calInProcess - amount
return intEarned
}
func earned30days(iEarned float64, years float64) (float64, error) {
if years*365 < 30 {
return 0, fmt.Errorf("NewDeposit period in years %v should not be less than 30 days", years)
}
i1Day := iEarned / (years * 365)
i30 := i1Day * 30
return math.Round(i30*100) / 100, nil
} | interestcal/interestvalue/cal.go | 0.654343 | 0.403244 | cal.go | starcoder |
package model
type BackendDummy struct {
}
func NewBackendDummy() (Backend, error) {
return BackendDummy{}, nil
}
func (b BackendDummy) FindUserByID(id int) (map[string]UserGroup, error) {
if id == 1 {
return map[string]UserGroup{
"test": &User{
Base: Base{
ID: 1,
Name: "test",
},
Password: <PASSWORD>",
},
},
nil
}
return nil, NewNotFoundError("user", "dummy")
}
func (b BackendDummy) FindUserByName(name string) (map[string]UserGroup, error) {
if name == "test" {
return map[string]UserGroup{
"test": &User{
Base: Base{
ID: 1,
Name: "test",
},
Password: <PASSWORD>",
},
},
nil
}
return nil, NewNotFoundError("user", "dummy")
}
func (b BackendDummy) Users() (map[string]UserGroup, error) {
return map[string]UserGroup{
"test": &User{
Base: Base{
ID: 1,
Name: "test",
},
Password: <PASSWORD> <KEY>",
},
},
nil
}
func (b BackendDummy) FindGroupByID(id int) (map[string]UserGroup, error) {
if id == 1 {
return map[string]UserGroup{
"test": &Group{
Base: Base{
ID: 1,
Name: "test",
},
},
},
nil
}
return nil, NewNotFoundError("group", "dummy")
}
func (b BackendDummy) FindGroupByName(name string) (map[string]UserGroup, error) {
if name == "test" {
return map[string]UserGroup{
"test": &Group{
Base: Base{
ID: 1,
Name: "test",
},
},
},
nil
}
return nil, NewNotFoundError("group", "dummy")
}
func (b BackendDummy) Groups() (map[string]UserGroup, error) {
return map[string]UserGroup{
"test": &Group{
Base: Base{
ID: 1,
Name: "test",
},
},
},
nil
}
func (b BackendDummy) HighestUserID() int {
return 10
}
func (b BackendDummy) LowestUserID() int {
return 1
}
func (b BackendDummy) HighestGroupID() int {
return 20
}
func (b BackendDummy) LowestGroupID() int {
return 2
}
func (b BackendDummy) CreateUser(v UserGroup) error {
return nil
}
func (b BackendDummy) CreateGroup(v UserGroup) error {
return nil
}
func (b BackendDummy) DeleteUser(id int) error {
return nil
}
func (b BackendDummy) DeleteGroup(id int) error {
return nil
}
func (b BackendDummy) UpdateUser(v UserGroup) error {
return nil
}
func (b BackendDummy) UpdateGroup(v UserGroup) error {
return nil
} | v2/model/dummy.go | 0.556641 | 0.417865 | dummy.go | starcoder |
package dns
import (
"fmt"
)
const (
// AType is the RR type representing a host address
AType Type = 1
// NSType is the RR type representing an authoritative name server
NSType Type = 2
// MDType is the RR type representing a mail destination (obsolote, use MX)
MDType Type = 3
// MFType is the RR type representing a mail forwarder (obsolote, use MX)
MFType Type = 4
// CNAMEType is the RR type representing a canonical name for an alias
CNAMEType Type = 5
// SOAType is the RR type representing the start of a zone of authority
SOAType Type = 6
// MBType is the RR type representing a mailbox domain name (experimental)
MBType Type = 7
// MGType is the RR type representing a mail group member (experimental)
MGType Type = 8
// MRType is the RR type representing a mail rename domain name (experimental)
MRType Type = 9
// NULLType is the RR type representing a null RR (experimental)
NULLType Type = 10
// WKSType is the RR type representing a well known service description
WKSType Type = 11
// PTRType is the RR type representing a domain name pointer
PTRType Type = 12
// HINFOType is the RR type representing a host information
HINFOType Type = 13
// MINFOType is the RR type representing a mailbox or mail list information
MINFOType Type = 14
// MXType is the RR type representing a mail exchange
MXType Type = 15
// TXTType is the RR type representing text strings
TXTType Type = 16
// AAAAType is the RR type representing a ipv6 host address
AAAAType Type = 28
// CAAType is the RR type representing a DNS Certification Authority Authorization
CAAType Type = 257
)
const (
// AXFRQType is the query type requesting a transfer of an entire zone
AXFRQType QType = 252
// MAILBQType is the query type requesting for mailbox-related records (MB, MG or MR)
MAILBQType QType = 253
// MAILAQType is the query type requesting for mail agent RR (obsolete, use MX)
MAILAQType QType = 254
// ANYQType is the query type requesting all records
ANYQType QType = 255
)
const (
// INClass is the class representing the Internet
INClass Class = 1
// CSClass is the class representing the CSNET (obsolete)
CSClass Class = 2
// CHClass is the class representing the CHAOS
CHClass Class = 3
// HSClass is the class representing the Hesiod
HSClass Class = 4
// ANYClass is the class representing any class
ANYClass Class = 255
)
// Type represents the type of the resource record.
type Type uint16
func extractType(left, right byte) (Type, error) {
value := uint16(left)<<8 | uint16(right)
switch value {
case 1:
return AType, nil
case 2:
return NSType, nil
case 3:
return MDType, nil
case 4:
return MFType, nil
case 5:
return CNAMEType, nil
case 6:
return SOAType, nil
case 7:
return MBType, nil
case 8:
return MGType, nil
case 9:
return MRType, nil
case 10:
return NULLType, nil
case 11:
return WKSType, nil
case 12:
return PTRType, nil
case 13:
return HINFOType, nil
case 14:
return MINFOType, nil
case 15:
return MXType, nil
case 16:
return TXTType, nil
case 28:
return AAAAType, nil
case 257:
return CAAType, nil
default:
return 0, fmt.Errorf("failed to extract type. invalid value 0x%x", value)
}
}
func (t Type) String() string {
return QType(t).String()
}
// QType represents the type of a query. It is a superset of Type. All Type are valid Qtype.
type QType Type
func (t QType) String() string {
switch t {
case QType(AType):
return "A"
case QType(NSType):
return "NS"
case QType(MDType):
return "MD"
case QType(MFType):
return "MF"
case QType(CNAMEType):
return "CNAME"
case QType(SOAType):
return "SOA"
case QType(MBType):
return "MB"
case QType(MGType):
return "MG"
case QType(MRType):
return "MR"
case QType(NULLType):
return "NULL"
case QType(WKSType):
return "WKS"
case QType(PTRType):
return "PTR"
case QType(HINFOType):
return "HINFO"
case QType(MINFOType):
return "MINFO"
case QType(MXType):
return "MX"
case QType(TXTType):
return "TXT"
case QType(AAAAType):
return "AAAA"
case QType(CAAType):
return "CAA"
case AXFRQType:
return "AXFRQ"
case MAILBQType:
return "MAILB"
case MAILAQType:
return "MAILA"
case ANYQType:
return "ANY"
default:
return "Unknown"
}
}
func extractQType(left, right byte) (QType, error) {
value := uint16(left)<<8 | uint16(right)
switch value {
case 252:
return AXFRQType, nil
case 253:
return MAILBQType, nil
case 254:
return MAILAQType, nil
case 255:
return ANYQType, nil
default:
t, err := extractType(left, right)
return QType(t), err
}
}
// Class represents the class of the resource record.
type Class uint16
func (c Class) String() string {
switch c {
case INClass:
return "IN"
case CSClass:
return "CS"
case CHClass:
return "CH"
case HSClass:
return "HS"
case ANYClass:
return "ANY"
default:
return "Unknown"
}
}
func extractClass(left, right byte) (Class, error) {
value := uint16(left)<<8 | uint16(right)
switch value {
case 1:
return INClass, nil
case 2:
return CSClass, nil
case 3:
return CHClass, nil
case 4:
return HSClass, nil
case 255:
return ANYClass, nil
default:
return ANYClass, fmt.Errorf("failed to extract class. invalid value 0x%x", value)
}
}
// ResourceRecord represents a DNS resource record
type ResourceRecord struct {
Name Name
Type Type
Class Class
TTL int32
DataLength uint16
Data []byte
}
// ToBytes returns the byte array form of the resource record to be transmitted
// over the wire
func (rr *ResourceRecord) ToBytes() []byte {
data := make([]byte, 0, 0)
data = append(data, rr.Name.ToBytes()...)
data = append(data, byte(rr.Type>>8))
data = append(data, byte(rr.Type&0xFF))
data = append(data, byte(rr.Class>>8))
data = append(data, byte(rr.Class&0xFF))
data = append(data, byte(rr.TTL>>24))
data = append(data, byte(rr.TTL>>16))
data = append(data, byte(rr.TTL>>8))
data = append(data, byte(rr.TTL&0xFF))
data = append(data, byte(rr.DataLength>>8))
data = append(data, byte(rr.DataLength&0xFF))
data = append(data, rr.Data...)
return data
}
func (rr ResourceRecord) stringLines() []string {
return []string{
fmt.Sprintf("[name] %s", rr.Name.GetName()),
fmt.Sprintf("[type] %s", rr.Type),
fmt.Sprintf("[class] %s", rr.Class),
fmt.Sprintf("[ttl] %d", rr.TTL),
fmt.Sprintf("[data] %v", rr.Data),
}
}
func resourceRecordFromBytes(data []byte, offset int) (ResourceRecord, int, error) {
n := 0
name := Name{}
bytesRead, err := name.fromBytes(data, offset)
if err != nil {
return ResourceRecord{}, 0, err
}
n += bytesRead
offset += bytesRead
rtype, err := extractType(data[offset], data[offset+1])
if err != nil {
return ResourceRecord{}, 0, err
}
n += 2
offset += 2
class, err := extractClass(data[offset], data[offset+1])
if err != nil {
return ResourceRecord{}, 0, err
}
n += 2
offset += 2
ttl := int32(data[offset])<<24 | int32(data[offset+1])<<16 | int32(data[offset+2])<<8 | int32(data[offset+3])
n += 4
offset += 4
dataLength := uint16(data[offset])<<8 | uint16(data[offset+1])
n += 2
offset += 2
rdata := data[offset : offset+int(dataLength)]
n += int(dataLength)
return ResourceRecord{
Name: name,
Type: rtype,
Class: class,
TTL: ttl,
DataLength: dataLength,
Data: rdata,
}, n, nil
} | dns/rr.go | 0.603815 | 0.544135 | rr.go | starcoder |
package rasterx
import (
"image"
"math"
"image/color"
"golang.org/x/image/math/fixed"
"golang.org/x/image/vector"
)
type (
ColorFuncImage struct {
image.Uniform
colorFunc ColorFunc
}
// Rasterizer converts a path to a raster using the grainless algorithm.
ScannerGV struct {
r vector.Rasterizer
//a, first fixed.Point26_6
Dest *image.RGBA
Targ image.Rectangle
colFImage *ColorFuncImage
Source image.Image
Offset image.Point
minX, minY, maxX, maxY fixed.Int26_6 // keep track of bounds
}
)
func (s *ScannerGV) GetPathExtent() fixed.Rectangle26_6 {
return fixed.Rectangle26_6{fixed.Point26_6{s.minX, s.minY}, fixed.Point26_6{s.maxX, s.maxY}}
}
func (c *ColorFuncImage) At(x, y int) color.Color {
return c.colorFunc(x, y)
}
func (s *ScannerGV) SetWinding(useNonZeroWinding bool) {
// no-op as scanner gv does not support even-odd winding
}
func (s *ScannerGV) SetColor(clr interface{}) {
switch c := clr.(type) {
case color.Color:
s.Source = &s.colFImage.Uniform
s.colFImage.Uniform.C = c
case ColorFunc:
s.Source = s.colFImage
s.colFImage.colorFunc = c
}
}
func (s *ScannerGV) set(a fixed.Point26_6) {
if s.maxX < a.X {
s.maxX = a.X
}
if s.maxY < a.Y {
s.maxY = a.Y
}
if s.minX > a.X {
s.minX = a.X
}
if s.minY > a.Y {
s.minY = a.Y
}
}
// Start starts a new path at the given point.
func (s *ScannerGV) Start(a fixed.Point26_6) {
s.set(a)
s.r.MoveTo(float32(a.X)/64, float32(a.Y)/64)
}
// Line adds a linear segment to the current curve.
func (s *ScannerGV) Line(b fixed.Point26_6) {
s.set(b)
s.r.LineTo(float32(b.X)/64, float32(b.Y)/64)
}
func (s *ScannerGV) Draw() {
// This draws the entire bounds of the image, because
// at this point the alpha mask does not shift with the
// placement of the target rectangle in the vector rasterizer
s.r.Draw(s.Dest, s.Dest.Bounds(), s.Source, s.Offset)
// Remove the line above and uncomment the lines below if you
// are using a version of the vector rasterizer that shifts the alpha
// mask with the placement of the target
// s.Targ.Min.X = int(s.minX >> 6)
// s.Targ.Min.Y = int(s.minY >> 6)
// s.Targ.Max.X = int(s.maxX>>6) + 1
// s.Targ.Max.Y = int(s.maxY>>6) + 1
// s.Targ = s.Targ.Intersect(s.Dest.Bounds()) // This check should be done by the rasterizer?
// s.r.Draw(s.Dest, s.Targ, s.Source, s.Offset)
}
// Clear cancels any previous accumulated scans
func (s *ScannerGV) Clear() {
p := s.r.Size()
s.r.Reset(p.X, p.Y)
const mxfi = fixed.Int26_6(math.MaxInt32)
s.minX, s.minY, s.maxX, s.maxY = mxfi, mxfi, -mxfi, -mxfi
}
// SetBounds sets the maximum width and height of the rasterized image and
// calls Clear. The width and height are in pixels, not fixed.Int26_6 units.
func (s *ScannerGV) SetBounds(width, height int) {
s.r.Reset(width, height)
}
// NewScanner creates a new Scanner with the given bounds.
func NewScannerGV(width, height int, dest *image.RGBA,
targ image.Rectangle) *ScannerGV {
s := new(ScannerGV)
s.SetBounds(width, height)
s.Dest = dest
s.Targ = targ
s.colFImage = &ColorFuncImage{}
s.colFImage.Uniform.C = &color.RGBA{255, 0, 0, 255}
s.Source = &s.colFImage.Uniform
s.Offset = image.Point{0, 0}
return s
} | vendor/github.com/whosonfirst/go-whosonfirst-static/vendor/github.com/whosonfirst/go-whosonfirst-image/vendor/github.com/srwiley/rasterx/scan.go | 0.759493 | 0.490114 | scan.go | starcoder |
package helpers
import (
"fmt"
"time"
)
// MaxInt returns the larger int value of the two given values.
func MaxInt(a, b int) int {
if a > b {
return a
}
return b
}
// MinInt returns the lower int value of the two given values.
func MinInt(a, b int) int {
if a < b {
return a
}
return b
}
// FormatBytes format a given byte value to a human readable format.
// See: https://programming.guide/go/formatting-byte-size-to-human-readable-format.html
func FormatBytes(b int64) string {
const unit = 1024
if b < unit {
return fmt.Sprintf("%dB", b)
}
div, exp := int64(unit), 0
for n := b / unit; n >= unit; n /= unit {
div *= unit
exp++
}
return fmt.Sprintf("%.0f%ci", float64(b)/float64(div), "KMGTPE"[exp])
}
// FormatDuration format a given duration to a human readable format.
func FormatDuration(d time.Duration) string {
if d.Hours() > 24*365 {
return fmt.Sprintf("%.0fy", d.Hours()/(24*365))
} else if d.Hours() > 120 {
return fmt.Sprintf("%.0fd", d.Hours()/24)
} else if d.Hours() > 10 {
return fmt.Sprintf("%.0fh", d.Hours())
} else if d.Minutes() > 10 {
return fmt.Sprintf("%.0fm", d.Minutes())
}
return fmt.Sprintf("%.0fs", d.Seconds())
}
// RenderMemoryMax renders the value for the memory limit of a pod.
// This is needed when multiple containers run in one pod but not all containers have an limit defined.
// If some containers have not a limit return the number of containers which contain a limit.
func RenderMemoryMax(memoryMax, memoryMaxContainerCount, containerCount int64) string {
if memoryMax == 0 {
return "-"
}
if memoryMaxContainerCount == containerCount {
return FormatBytes(memoryMax)
}
return fmt.Sprintf("%s (%d)", FormatBytes(memoryMax), memoryMaxContainerCount)
}
// RenderCPUMax renders the value for the cpu limit of a pod.
// This is needed when multiple containers run in one pod but not all containers have an limit defined.
// If some containers have not a limit return the number of containers which contain a limit.
func RenderCPUMax(cpuMax, cpuMaxContainerCount, containerCount int64) string {
if cpuMax == 0 {
return "-"
}
if cpuMaxContainerCount == containerCount {
return fmt.Sprintf("%dm", cpuMax)
}
return fmt.Sprintf("%dm (%d)", cpuMax, cpuMaxContainerCount)
} | pkg/term/helpers/helpers.go | 0.794385 | 0.518485 | helpers.go | starcoder |
package main
import (
"crypto/elliptic"
"crypto/rand"
"math/big"
"fmt"
"encoding/hex"
)
var fakeRandom = true
type Scalar struct {
data []byte
}
type Point struct {
x *big.Int
y *big.Int
}
type DhSecret struct {
data []byte // pre-form of an actual DH secret on elliptic curve
}
type KeyPair struct {
private Scalar
public Point
}
func (s Scalar) String() string {
bi := s.toInt()
return fmt.Sprintf("Scalar %s", bi.String())
}
func (p Point) String() string {
return fmt.Sprintf("Point {x = %d,y = %d}", p.x, p.y)
}
func (dh DhSecret) String() string {
return hex.EncodeToString(dh.data)
}
// hardcoded choice of curve
func getCurve() elliptic.Curve {
return elliptic.P256()
}
func getCurveParams() *elliptic.CurveParams {
return getCurve().Params()
}
func keypairGen() KeyPair {
if fakeRandom {
priv := new (Scalar).fromSmallInt(1)
pub := priv.toPoint()
return KeyPair { *priv, pub }
} else {
priv, x, y, _ := elliptic.GenerateKey(getCurve(), rand.Reader)
return KeyPair { Scalar { priv }, Point { x, y } }
}
}
func (s Scalar) toInt() *big.Int {
return new(big.Int).SetBytes(s.data)
}
func (s *Scalar) fromInt(bi *big.Int) *Scalar {
order := getCurveParams().N
bitSize := getCurveParams().BitSize
if bi.Cmp(big.NewInt(0)) == -1 {
bi.Add(bi, order)
}
b := bi.Bytes()
blen := cap(b)
nbBytes := bitSize / 8
switch {
case blen == nbBytes: // expected size already
s.data = b
case blen < nbBytes: // complete with 0
s.data = make([]byte, nbBytes)
copy(s.data[nbBytes - blen:], b)
}
return s
}
func (s *Scalar) fromSmallInt(i int) *Scalar {
bi := big.NewInt(int64(i))
return s.fromInt(bi)
}
func (s *Scalar) Add(a *Scalar, b *Scalar) *Scalar {
r := new (big.Int).Add(a.toInt(),b.toInt())
r2 := r.Mod(r, getCurveParams().N)
s.fromInt(r2)
return s
}
func (s *Scalar) Mul(a *Scalar, b *Scalar) *Scalar {
r := new (big.Int).Mul(a.toInt(),b.toInt())
r2 := r.Mod(r, getCurveParams().N)
s.fromInt(r2)
return s
}
func (s *Scalar) Inverse(a *Scalar) *Scalar {
bi := a.toInt()
inv := bi.ModInverse(bi, getCurveParams().N)
s.fromInt(inv)
return s
}
// lift to curve a scalar
func (s *Scalar) toPoint() Point {
x,y := getCurve().ScalarBaseMult(s.data)
return (Point { x, y })
}
func (p *Point) Add(a *Point, b *Point) *Point{
r := new(Point)
r.x, r.y = getCurve().Add(a.x, a.y, b.x, b.y)
return r
}
func PointMul(p *Point, s *Scalar) *Point {
r := new(Point)
r.x, r.y = getCurve().ScalarMult(p.x, p.y, s.data)
return r
}
// same as PointMul, but multiply by the modular inverse
func PointDiv(p *Point, s *Scalar) *Point {
sInv := new (Scalar).Inverse(s)
return PointMul(p, sInv)
}
func (p *Point) ToDhSecret() DhSecret {
return DhSecret {p.x.Bytes()}
} | crypto.go | 0.835181 | 0.439326 | crypto.go | starcoder |
package datagen
import (
"errors"
"math"
"time"
"github.com/paulidealiste/goalgs/utilgen"
)
type Heap struct {
Heapsize int
Length int
Inslice []float64
}
type Bst struct {
Bstsize int
Rootnode *Bstnode
Innerslice []float64
Inslice []Bstnode
}
type Bstnode struct {
data float64
leftchild *Bstnode
rightchild *Bstnode
parent *Bstnode
}
// Bstgen tries to transform input slice into a binary search tree representation
// where each datum is reperesented by a node with a key which satisfies criteria
// that key in left child is always smaller than the key of the parent while the
// same key in the right child is always larger.
func Bstgen(inslice []float64) Bst {
defer utilgen.Timetracker(time.Now(), "Bstgen")
innerslice := make([]float64, len(inslice))
copy(innerslice, inslice)
var bstlist []Bstnode
innerbst := Bst{0, nil, innerslice, bstlist}
bstgencreate(&innerbst)
return innerbst
}
func bstgencreate(inbst *Bst) {
for i := 0; i < len(inbst.Innerslice)-1; i++ {
insertnode := Bstnode{inbst.Innerslice[i], nil, nil, nil}
inbst.Insert(&insertnode)
}
}
// Binary search tree maintenance methods
// Bst.Insert() acts by inserting new Bstnode element at appropriate position
// so that basic premises of the binary search tree are maintained
func (inbst *Bst) Insert(insertnode *Bstnode) {
if inbst.Rootnode == nil {
inbst.Rootnode = insertnode
} else {
currentRoot := inbst.Rootnode
for {
if insertnode.data > currentRoot.data {
if currentRoot.rightchild == nil {
currentRoot.rightchild = insertnode
inbst.Inslice = append(inbst.Inslice, *currentRoot)
inbst.Bstsize++
break
} else {
currentRoot = currentRoot.rightchild
}
} else {
if currentRoot.leftchild == nil {
currentRoot.leftchild = insertnode
inbst.Inslice = append(inbst.Inslice, *currentRoot)
inbst.Bstsize++
break
} else {
currentRoot = currentRoot.leftchild
}
}
}
}
}
// Heapgen generates a max-heap data structure which is a tree-like representation
// of the input array where each value of a parent element is greater than that of
// a child.
func Heapgen(Inslice []float64) Heap {
defer utilgen.Timetracker(time.Now(), "Heapgen")
innerslice := make([]float64, len(Inslice))
copy(innerslice, Inslice)
inheap := Heap{len(Inslice) - 1, len(Inslice) - 1, innerslice}
for i := inheap.Length / 2; i >= 0; i-- {
Maxheapmaintain(&inheap, i)
}
return inheap
}
func Maxheapmaintain(inheap *Heap, driver int) {
l := 2*driver + 1
r := l + 1
largest := driver
if l < inheap.Heapsize && inheap.Inslice[l] > inheap.Inslice[driver] {
largest = l
}
if r <= inheap.Heapsize && inheap.Inslice[r] > inheap.Inslice[largest] {
largest = r
}
if largest != driver {
inheap.Inslice[driver], inheap.Inslice[largest] = inheap.Inslice[largest], inheap.Inslice[driver]
Maxheapmaintain(inheap, largest)
}
}
// Heap maintenance methods // assuming that keys are indices to a Heap.Inslice slice
// Heap.maximum() returns the maximum of the generated max-heap
func (h *Heap) Maximum() float64 {
return h.Inslice[0]
}
// Heap.extractmax() removes and returns the element of the heap with the largest key
func (h *Heap) Extractmax() (float64, error) {
if h.Heapsize < 1 {
return -1.0, errors.New("Heap underflow error. Heap size less than 1.")
}
cmax := h.Inslice[0]
h.Inslice[0] = h.Inslice[h.Heapsize]
h.Heapsize--
h.Inslice = h.Inslice[:h.Heapsize+1]
Maxheapmaintain(h, 0)
return cmax, nil
}
// Heap.increasekey() goes on to increase the value of the element's current key
// (elementkey) to the new position specified by targetkey's value.
func (h *Heap) Increasekey(elementkey int, targetkey float64) error {
if targetkey < h.Inslice[elementkey] {
return errors.New("New key is smaller than the current key, which is not allowed in max-heap increasekey.")
}
h.Inslice[elementkey] = targetkey
for elementkey > 1 && h.Inslice[elementkey>>1] < h.Inslice[elementkey] {
h.Inslice[elementkey], h.Inslice[elementkey>>1] = h.Inslice[elementkey>>1], h.Inslice[elementkey]
elementkey = elementkey >> 1
}
return nil
}
// Heap.insert() inserts the targetkey value in the appropriate place in the heap
// tree structure thus maintaining the max-heap property
func (h *Heap) Insert(targetkey float64) {
h.Heapsize++
h.Inslice = append(h.Inslice, math.MaxFloat64*-1)
h.Increasekey(h.Heapsize, targetkey)
} | datagen/datagen.go | 0.741955 | 0.483648 | datagen.go | starcoder |
package statistics
import (
"encoding/binary"
"math"
"github.com/pingcap/parser/mysql"
"github.com/pingcap/tidb/sessionctx/stmtctx"
"github.com/pingcap/tidb/trace_util_0"
"github.com/pingcap/tidb/types"
)
// calcFraction is used to calculate the fraction of the interval [lower, upper] that lies within the [lower, value]
// using the continuous-value assumption.
func calcFraction(lower, upper, value float64) float64 {
trace_util_0.Count(_scalar_00000, 0)
if upper <= lower {
trace_util_0.Count(_scalar_00000, 5)
return 0.5
}
trace_util_0.Count(_scalar_00000, 1)
if value <= lower {
trace_util_0.Count(_scalar_00000, 6)
return 0
}
trace_util_0.Count(_scalar_00000, 2)
if value >= upper {
trace_util_0.Count(_scalar_00000, 7)
return 1
}
trace_util_0.Count(_scalar_00000, 3)
frac := (value - lower) / (upper - lower)
if math.IsNaN(frac) || math.IsInf(frac, 0) || frac < 0 || frac > 1 {
trace_util_0.Count(_scalar_00000, 8)
return 0.5
}
trace_util_0.Count(_scalar_00000, 4)
return frac
}
func convertDatumToScalar(value *types.Datum, commonPfxLen int) float64 {
trace_util_0.Count(_scalar_00000, 9)
switch value.Kind() {
case types.KindMysqlDecimal:
trace_util_0.Count(_scalar_00000, 10)
scalar, err := value.GetMysqlDecimal().ToFloat64()
if err != nil {
trace_util_0.Count(_scalar_00000, 17)
return 0
}
trace_util_0.Count(_scalar_00000, 11)
return scalar
case types.KindMysqlTime:
trace_util_0.Count(_scalar_00000, 12)
valueTime := value.GetMysqlTime()
var minTime types.Time
switch valueTime.Type {
case mysql.TypeDate:
trace_util_0.Count(_scalar_00000, 18)
minTime = types.Time{
Time: types.MinDatetime,
Type: mysql.TypeDate,
Fsp: types.DefaultFsp,
}
case mysql.TypeDatetime:
trace_util_0.Count(_scalar_00000, 19)
minTime = types.Time{
Time: types.MinDatetime,
Type: mysql.TypeDatetime,
Fsp: types.DefaultFsp,
}
case mysql.TypeTimestamp:
trace_util_0.Count(_scalar_00000, 20)
minTime = types.MinTimestamp
}
trace_util_0.Count(_scalar_00000, 13)
sc := &stmtctx.StatementContext{TimeZone: types.BoundTimezone}
return float64(valueTime.Sub(sc, &minTime).Duration)
case types.KindString, types.KindBytes:
trace_util_0.Count(_scalar_00000, 14)
bytes := value.GetBytes()
if len(bytes) <= commonPfxLen {
trace_util_0.Count(_scalar_00000, 21)
return 0
}
trace_util_0.Count(_scalar_00000, 15)
return convertBytesToScalar(bytes[commonPfxLen:])
default:
trace_util_0.Count(_scalar_00000, 16)
// do not know how to convert
return 0
}
}
// PreCalculateScalar converts the lower and upper to scalar. When the datum type is KindString or KindBytes, we also
// calculate their common prefix length, because when a value falls between lower and upper, the common prefix
// of lower and upper equals to the common prefix of the lower, upper and the value. For some simple types like `Int64`,
// we do not convert it because we can directly infer the scalar value.
func (hg *Histogram) PreCalculateScalar() {
trace_util_0.Count(_scalar_00000, 22)
len := hg.Len()
if len == 0 {
trace_util_0.Count(_scalar_00000, 24)
return
}
trace_util_0.Count(_scalar_00000, 23)
switch hg.GetLower(0).Kind() {
case types.KindMysqlDecimal, types.KindMysqlTime:
trace_util_0.Count(_scalar_00000, 25)
hg.scalars = make([]scalar, len)
for i := 0; i < len; i++ {
trace_util_0.Count(_scalar_00000, 27)
hg.scalars[i] = scalar{
lower: convertDatumToScalar(hg.GetLower(i), 0),
upper: convertDatumToScalar(hg.GetUpper(i), 0),
}
}
case types.KindBytes, types.KindString:
trace_util_0.Count(_scalar_00000, 26)
hg.scalars = make([]scalar, len)
for i := 0; i < len; i++ {
trace_util_0.Count(_scalar_00000, 28)
lower, upper := hg.GetLower(i), hg.GetUpper(i)
common := commonPrefixLength(lower.GetBytes(), upper.GetBytes())
hg.scalars[i] = scalar{
commonPfxLen: common,
lower: convertDatumToScalar(lower, common),
upper: convertDatumToScalar(upper, common),
}
}
}
}
func (hg *Histogram) calcFraction(index int, value *types.Datum) float64 {
trace_util_0.Count(_scalar_00000, 29)
lower, upper := hg.Bounds.GetRow(2*index), hg.Bounds.GetRow(2*index+1)
switch value.Kind() {
case types.KindFloat32:
trace_util_0.Count(_scalar_00000, 31)
return calcFraction(float64(lower.GetFloat32(0)), float64(upper.GetFloat32(0)), float64(value.GetFloat32()))
case types.KindFloat64:
trace_util_0.Count(_scalar_00000, 32)
return calcFraction(lower.GetFloat64(0), upper.GetFloat64(0), value.GetFloat64())
case types.KindInt64:
trace_util_0.Count(_scalar_00000, 33)
return calcFraction(float64(lower.GetInt64(0)), float64(upper.GetInt64(0)), float64(value.GetInt64()))
case types.KindUint64:
trace_util_0.Count(_scalar_00000, 34)
return calcFraction(float64(lower.GetUint64(0)), float64(upper.GetUint64(0)), float64(value.GetUint64()))
case types.KindMysqlDuration:
trace_util_0.Count(_scalar_00000, 35)
return calcFraction(float64(lower.GetDuration(0, 0).Duration), float64(upper.GetDuration(0, 0).Duration), float64(value.GetMysqlDuration().Duration))
case types.KindMysqlDecimal, types.KindMysqlTime:
trace_util_0.Count(_scalar_00000, 36)
return calcFraction(hg.scalars[index].lower, hg.scalars[index].upper, convertDatumToScalar(value, 0))
case types.KindBytes, types.KindString:
trace_util_0.Count(_scalar_00000, 37)
return calcFraction(hg.scalars[index].lower, hg.scalars[index].upper, convertDatumToScalar(value, hg.scalars[index].commonPfxLen))
}
trace_util_0.Count(_scalar_00000, 30)
return 0.5
}
func commonPrefixLength(lower, upper []byte) int {
trace_util_0.Count(_scalar_00000, 38)
minLen := len(lower)
if minLen > len(upper) {
trace_util_0.Count(_scalar_00000, 41)
minLen = len(upper)
}
trace_util_0.Count(_scalar_00000, 39)
for i := 0; i < minLen; i++ {
trace_util_0.Count(_scalar_00000, 42)
if lower[i] != upper[i] {
trace_util_0.Count(_scalar_00000, 43)
return i
}
}
trace_util_0.Count(_scalar_00000, 40)
return minLen
}
func convertBytesToScalar(value []byte) float64 {
trace_util_0.Count(_scalar_00000, 44)
// Bytes type is viewed as a base-256 value, so we only consider at most 8 bytes.
var buf [8]byte
copy(buf[:], value)
return float64(binary.BigEndian.Uint64(buf[:]))
}
func calcFraction4Datums(lower, upper, value *types.Datum) float64 {
trace_util_0.Count(_scalar_00000, 45)
switch value.Kind() {
case types.KindFloat32:
trace_util_0.Count(_scalar_00000, 47)
return calcFraction(float64(lower.GetFloat32()), float64(upper.GetFloat32()), float64(value.GetFloat32()))
case types.KindFloat64:
trace_util_0.Count(_scalar_00000, 48)
return calcFraction(lower.GetFloat64(), upper.GetFloat64(), value.GetFloat64())
case types.KindInt64:
trace_util_0.Count(_scalar_00000, 49)
return calcFraction(float64(lower.GetInt64()), float64(upper.GetInt64()), float64(value.GetInt64()))
case types.KindUint64:
trace_util_0.Count(_scalar_00000, 50)
return calcFraction(float64(lower.GetUint64()), float64(upper.GetUint64()), float64(value.GetUint64()))
case types.KindMysqlDuration:
trace_util_0.Count(_scalar_00000, 51)
return calcFraction(float64(lower.GetMysqlDuration().Duration), float64(upper.GetMysqlDuration().Duration), float64(value.GetMysqlDuration().Duration))
case types.KindMysqlDecimal, types.KindMysqlTime:
trace_util_0.Count(_scalar_00000, 52)
return calcFraction(convertDatumToScalar(lower, 0), convertDatumToScalar(upper, 0), convertDatumToScalar(value, 0))
case types.KindBytes, types.KindString:
trace_util_0.Count(_scalar_00000, 53)
commonPfxLen := commonPrefixLength(lower.GetBytes(), upper.GetBytes())
return calcFraction(convertDatumToScalar(lower, commonPfxLen), convertDatumToScalar(upper, commonPfxLen), convertDatumToScalar(value, commonPfxLen))
}
trace_util_0.Count(_scalar_00000, 46)
return 0.5
}
var _scalar_00000 = "statistics/scalar.go" | statistics/scalar.go | 0.718002 | 0.453988 | scalar.go | starcoder |
package field
import (
"crypto/rand"
"io"
"math/big"
)
type fp2Elt struct {
a, b *big.Int
}
func (e fp2Elt) String() string {
return "\na: 0x" + e.a.Text(16) +
"\nb: 0x" + e.b.Text(16) + " * i"
}
func (e fp2Elt) Copy() Elt { r := &fp2Elt{}; r.a.Set(e.a); r.b.Set(e.b); return r }
type fp2 struct {
p *big.Int
name string
cte struct {
pMinus1div2 *big.Int
}
}
// NewFp2 creates a quadratic extension field Z/pZ[x] with irreducible polynomial x^2=-1 and given p as an int, uint, *big.Int or string.
func NewFp2(name string, p interface{}) Field {
prime := FromType(p)
if !prime.ProbablyPrime(4) {
panic("p is not prime")
}
return fp2{p: prime, name: name}
}
func (f fp2) Elt(in interface{}) Elt {
var a, b *big.Int
if v, ok := in.([]interface{}); ok && len(v) == 2 {
a = FromType(v[0])
b = FromType(v[1])
} else {
a = FromType(in)
b = big.NewInt(0)
}
return f.mod(a, b)
}
func (f fp2) P() *big.Int { return new(big.Int).Set(f.p) }
func (f fp2) Order() *big.Int { return new(big.Int).Mul(f.p, f.p) }
func (f fp2) String() string { return "GF(" + f.name + ") Irred: i^2+1" }
func (f fp2) Ext() uint { return uint(2) }
func (f fp2) Zero() Elt { return f.Elt(0) }
func (f fp2) One() Elt { return f.Elt(1) }
func (f fp2) BitLen() int { return f.p.BitLen() }
func (f fp2) AreEqual(x, y Elt) bool { return f.IsZero(f.Sub(x, y)) }
func (f fp2) IsEqual(ff Field) bool { return f.p.Cmp(ff.(fp2).p) == 0 }
func (f fp2) IsZero(x Elt) bool {
e := x.(*fp2Elt)
return e.a.Mod(e.a, f.p).Sign() == 0 &&
e.b.Mod(e.b, f.p).Sign() == 0
}
func (f fp2) Rand(r io.Reader) Elt {
a, _ := rand.Int(r, f.p)
b, _ := rand.Int(r, f.p)
return &fp2Elt{a, b}
}
func (f fp2) mod(a, b *big.Int) Elt { return &fp2Elt{a: a.Mod(a, f.p), b: b.Mod(b, f.p)} }
func (f fp2) Add(x, y Elt) Elt {
a := new(big.Int).Add(x.(fp2Elt).a, y.(fp2Elt).a)
b := new(big.Int).Add(x.(fp2Elt).b, y.(fp2Elt).b)
a.Mod(a, f.p)
b.Mod(b, f.p)
return fp2Elt{a, b}
}
func (f fp2) Sub(x, y Elt) Elt {
a := new(big.Int).Sub(x.(fp2Elt).a, y.(fp2Elt).a)
b := new(big.Int).Sub(x.(fp2Elt).b, y.(fp2Elt).b)
a.Mod(a, f.p)
b.Mod(b, f.p)
return fp2Elt{a, b}
}
func (f fp2) Mul(x, y Elt) Elt { return nil }
func (f fp2) Sqr(x Elt) Elt { return nil }
func (f fp2) Inv(x Elt) Elt { return nil }
func (f fp2) Neg(x Elt) Elt { return nil }
func (f fp2) Sqrt(x Elt) Elt { return nil }
func (f fp2) Exp(x Elt, e *big.Int) Elt { return nil }
func (f fp2) IsSquare(x Elt) bool { return false }
func (f fp2) Generator() Elt { return f.Elt([]string{"0", "1"}) }
func (f fp2) Inv0(x Elt) Elt { return f.Inv(x) }
func (f fp2) CMov(x, y Elt, b bool) Elt {
var za, zb big.Int
if b {
za.Set(y.(*fp2Elt).a)
zb.Set(y.(*fp2Elt).b)
} else {
za.Set(x.(*fp2Elt).a)
zb.Set(x.(*fp2Elt).b)
}
return &fp2Elt{&za, &zb}
}
func (f fp2) GetSgn0(id Sgn0ID) func(Elt) int {
if id == SignBE {
return f.Sgn0BE
}
if id == SignLE {
return f.Sgn0LE
}
panic("Wrong signID")
}
func (f fp2) Sgn0BE(x Elt) int {
/* [TODO] */
sb := x.(*fp2Elt).b.Sign()
cb := 2*(f.cte.pMinus1div2.Cmp(x.(*fp2Elt).b)&^1) - 1
sa := x.(*fp2Elt).a.Sign()
ca := 2*(f.cte.pMinus1div2.Cmp(x.(*fp2Elt).a)&^1) - 1
return sb*cb + (1-sb)*(sa*ca+(1-sa)*1)
}
func (f fp2) Sgn0LE(x Elt) int {
/* [TODO] */
sa := x.(*fp2Elt).a.Sign()
ca := 1 - 2*int(x.(*fp2Elt).a.Bit(0))
sb := x.(*fp2Elt).b.Sign()
cb := 1 - 2*int(x.(*fp2Elt).b.Bit(0))
return sa*ca + (1-sa)*(sb*cb+(1-sb)*1)
} | go-h2c/field/fp2.go | 0.561936 | 0.428712 | fp2.go | starcoder |
package algorithms
import (
"fmt"
"github.com/azeezolaniran2016/algorithm-tests/utils"
)
/*
A binary gap within a positive integer N is any maximal sequence of consecutive zeros that is surrounded by ones at both ends in the binary representation of N.
For example, number 9 has binary representation 1001 and contains a binary gap of length 2.
The number 529 has binary representation 1000010001 and contains two binary gaps: one of length 4 and one of length 3.
The number 20 has binary representation 10100 and contains one binary gap of length 1.
The number 15 has binary representation 1111 and has no binary gaps. The number 32 has binary representation 100000 and has no binary gaps.
Write a function:
func Solution(N int) int
that, given a positive integer N, returns the length of its longest binary gap.
The function should return 0 if N doesn't contain a binary gap.
For example, given N = 1041 the function should return 5, because N has binary representation 10000010001 and so its longest binary gap is of length 5.
Given N = 32 the function should return 0, because N has binary representation '100000' and thus no binary gaps.
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..2,147,483,647].
*/
// BinaryGap calculates binary gap following the requirements in the comments above
// ToDo: I got too lazy to comment what I did here, but should do it later ;)
func BinaryGap(n int) int {
binaryGap := 0
binary := utils.DecimalToBaseX(n, 2)
tempCount := 0
for idx := range binary {
if idx+1 < len(binary) {
if fmt.Sprintf("%c", binary[idx]) == "0" && fmt.Sprintf("%c", binary[idx+1]) == "1" {
if tempCount > binaryGap {
binaryGap = tempCount
tempCount = 0
}
}
if fmt.Sprintf("%c", binary[idx]) == "1" && fmt.Sprintf("%c", binary[idx+1]) == "0" {
tempCount = 1
}
}
if tempCount > 0 && fmt.Sprintf("%c", binary[idx]) == "0" {
tempCount++
}
if binaryGap > len(binary)/2 {
break
}
}
return binaryGap
} | algorithms/binary_gap.go | 0.716516 | 0.577883 | binary_gap.go | starcoder |
package torrent
import (
"math/rand"
"sort"
)
// BitTorrent choking policy.
// The choking policy's view of a peer. For current policies we only care
// about identity and download bandwidth.
type Choker interface {
DownloadBPS() float32 // bps
}
type ChokePolicy interface {
// Only pass in interested peers.
// mutate the chokers into a list where the first N are to be unchoked.
Choke(chokers []Choker) (unchokeCount int, err error)
}
// Our naive never-choke policy
type NeverChokePolicy struct{}
func (n *NeverChokePolicy) Choke(chokers []Choker) (unchokeCount int, err error) {
return len(chokers), nil
}
// Our interpretation of the classic bittorrent choke policy.
// Expects to be called once every 10 seconds.
// See the section "Choking and optimistic unchoking" in
// https://wiki.theory.org/BitTorrentSpecification
type ClassicChokePolicy struct {
optimisticUnchoker Choker // The choker we unchoked optimistically
counter int // When to choose a new optimisticUnchoker.
}
type ByDownloadBPS []Choker
func (a ByDownloadBPS) Len() int {
return len(a)
}
func (a ByDownloadBPS) Swap(i, j int) {
a[i], a[j] = a[j], a[i]
}
func (a ByDownloadBPS) Less(i, j int) bool {
return a[i].DownloadBPS() > a[j].DownloadBPS()
}
const HIGH_BANDWIDTH_SLOTS = 3
const OPTIMISTIC_UNCHOKE_INDEX = HIGH_BANDWIDTH_SLOTS
// How many cycles of this algorithm before we pick a new optimistic
const OPTIMISTIC_UNCHOKE_COUNT = 3
func (ccp *ClassicChokePolicy) Choke(chokers []Choker) (unchokeCount int, err error) {
sort.Sort(ByDownloadBPS(chokers))
optimistIndex := ccp.findOptimist(chokers)
if optimistIndex >= 0 {
if optimistIndex < OPTIMISTIC_UNCHOKE_INDEX {
// Forget optimistic choke
optimistIndex = -1
} else {
ByDownloadBPS(chokers).Swap(OPTIMISTIC_UNCHOKE_INDEX, optimistIndex)
optimistIndex = OPTIMISTIC_UNCHOKE_INDEX
}
}
if optimistIndex >= 0 {
ccp.counter++
if ccp.counter >= OPTIMISTIC_UNCHOKE_COUNT {
ccp.counter = 0
optimistIndex = -1
}
}
if optimistIndex < 0 {
candidateCount := len(chokers) - OPTIMISTIC_UNCHOKE_INDEX
if candidateCount > 0 {
candidate := OPTIMISTIC_UNCHOKE_INDEX + rand.Intn(candidateCount)
ByDownloadBPS(chokers).Swap(OPTIMISTIC_UNCHOKE_INDEX, candidate)
ccp.counter = 0
ccp.optimisticUnchoker = chokers[OPTIMISTIC_UNCHOKE_INDEX]
}
}
unchokeCount = OPTIMISTIC_UNCHOKE_INDEX + 1
if unchokeCount > len(chokers) {
unchokeCount = len(chokers)
}
return
}
func (ccp *ClassicChokePolicy) findOptimist(chokers []Choker) (index int) {
for i, c := range chokers {
if c == ccp.optimisticUnchoker {
return i
}
}
return -1
} | torrent/choker.go | 0.609873 | 0.441854 | choker.go | starcoder |
package gi
import (
"image/color"
"math"
"sort"
)
type stop struct {
pos float64
color color.Color
}
type stops []stop
// Len satisfies the Sort interface.
func (s stops) Len() int {
return len(s)
}
// Less satisfies the Sort interface.
func (s stops) Less(i, j int) bool {
return s[i].pos < s[j].pos
}
// Swap satisfies the Sort interface.
func (s stops) Swap(i, j int) {
s[i], s[j] = s[j], s[i]
}
type Gradient interface {
Pattern
AddColorStop(offset float64, color color.Color)
}
// Linear Gradient
type linearGradient struct {
x0, y0, x1, y1 float64
stops stops
}
func (g *linearGradient) ColorAt(x, y int) color.Color {
if len(g.stops) == 0 {
return color.Transparent
}
fx, fy := float64(x), float64(y)
x0, y0, x1, y1 := g.x0, g.y0, g.x1, g.y1
dx, dy := x1-x0, y1-y0
// Horizontal
if dy == 0 && dx != 0 {
return getColor((fx-x0)/dx, g.stops)
}
// Vertical
if dx == 0 && dy != 0 {
return getColor((fy-y0)/dy, g.stops)
}
// Dot product
s0 := dx*(fx-x0) + dy*(fy-y0)
if s0 < 0 {
return g.stops[0].color
}
// Calculate distance to (x0,y0) alone (x0,y0)->(x1,y1)
mag := math.Hypot(dx, dy)
u := ((fx-x0)*-dy + (fy-y0)*dx) / (mag * mag)
x2, y2 := x0+u*-dy, y0+u*dx
d := math.Hypot(fx-x2, fy-y2) / mag
return getColor(d, g.stops)
}
func (g *linearGradient) AddColorStop(offset float64, color color.Color) {
g.stops = append(g.stops, stop{pos: offset, color: color})
sort.Sort(g.stops)
}
func NewLinearGradient(x0, y0, x1, y1 float64) Gradient {
g := &linearGradient{
x0: x0, y0: y0,
x1: x1, y1: y1,
}
return g
}
// Radial Gradient
type circle struct {
x, y, r float64
}
type radialGradient struct {
c0, c1, cd circle
a, inva float64
mindr float64
stops stops
}
func dot3(x0, y0, z0, x1, y1, z1 float64) float64 {
return x0*x1 + y0*y1 + z0*z1
}
func (g *radialGradient) ColorAt(x, y int) color.Color {
if len(g.stops) == 0 {
return color.Transparent
}
// copy from pixman's pixman-radial-gradient.c
dx, dy := float64(x)+0.5-g.c0.x, float64(y)+0.5-g.c0.y
b := dot3(dx, dy, g.c0.r, g.cd.x, g.cd.y, g.cd.r)
c := dot3(dx, dy, -g.c0.r, dx, dy, g.c0.r)
if g.a == 0 {
if b == 0 {
return color.Transparent
}
t := 0.5 * c / b
if t*g.cd.r >= g.mindr {
return getColor(t, g.stops)
}
return color.Transparent
}
discr := dot3(b, g.a, 0, b, -c, 0)
if discr >= 0 {
sqrtdiscr := math.Sqrt(discr)
t0 := (b + sqrtdiscr) * g.inva
t1 := (b - sqrtdiscr) * g.inva
if t0*g.cd.r >= g.mindr {
return getColor(t0, g.stops)
} else if t1*g.cd.r >= g.mindr {
return getColor(t1, g.stops)
}
}
return color.Transparent
}
func (g *radialGradient) AddColorStop(offset float64, color color.Color) {
g.stops = append(g.stops, stop{pos: offset, color: color})
sort.Sort(g.stops)
}
func NewRadialGradient(x0, y0, r0, x1, y1, r1 float64) Gradient {
c0 := circle{x0, y0, r0}
c1 := circle{x1, y1, r1}
cd := circle{x1 - x0, y1 - y0, r1 - r0}
a := dot3(cd.x, cd.y, -cd.r, cd.x, cd.y, cd.r)
var inva float64
if a != 0 {
inva = 1.0 / a
}
mindr := -c0.r
g := &radialGradient{
c0: c0,
c1: c1,
cd: cd,
a: a,
inva: inva,
mindr: mindr,
}
return g
}
// Conic Gradient
type conicGradient struct {
cx, cy float64
rotation float64
stops stops
}
func (g *conicGradient) ColorAt(x, y int) color.Color {
if len(g.stops) == 0 {
return color.Transparent
}
a := math.Atan2(float64(y)-g.cy, float64(x)-g.cx)
t := norm(a, -math.Pi, math.Pi) - g.rotation
if t < 0 {
t += 1
}
return getColor(t, g.stops)
}
func (g *conicGradient) AddColorStop(offset float64, color color.Color) {
g.stops = append(g.stops, stop{pos: offset, color: color})
sort.Sort(g.stops)
}
func NewConicGradient(cx, cy, deg float64) Gradient {
g := &conicGradient{
cx: cx,
cy: cy,
rotation: normalizeAngle(deg) / 360,
}
return g
}
func normalizeAngle(t float64) float64 {
t = math.Mod(t, 360)
if t < 0 {
t += 360
}
return t
}
// Map value which is in range [a..b] to range [0..1]
func norm(value, a, b float64) float64 {
return (value - a) * (1.0 / (b - a))
}
func getColor(pos float64, stops stops) color.Color {
if pos <= 0.0 || len(stops) == 1 {
return stops[0].color
}
last := stops[len(stops)-1]
if pos >= last.pos {
return last.color
}
for i, stop := range stops[1:] {
if pos < stop.pos {
pos = (pos - stops[i].pos) / (stop.pos - stops[i].pos)
return colorLerp(stops[i].color, stop.color, pos)
}
}
return last.color
}
func colorLerp(c0, c1 color.Color, t float64) color.Color {
r0, g0, b0, a0 := c0.RGBA()
r1, g1, b1, a1 := c1.RGBA()
return color.RGBA{
lerp(r0, r1, t),
lerp(g0, g1, t),
lerp(b0, b1, t),
lerp(a0, a1, t),
}
}
func lerp(a, b uint32, t float64) uint8 {
return uint8(int32(float64(a)*(1.0-t)+float64(b)*t) >> 8)
} | gradient.go | 0.774498 | 0.409752 | gradient.go | starcoder |
package asetypes
import (
"database/sql/driver"
"fmt"
"reflect"
)
// ConvertValue converts a value-interface of an ASE data type into
// a database/sql/driver.Value with the respective golang data type.
func (t DataType) ConvertValue(v interface{}) (driver.Value, error) {
sv := reflect.ValueOf(v)
// Return value as-is if the type already matches.
if sv.Type() == ReflectTypes[t] {
return v, nil
}
switch t {
case INT1:
switch sv.Kind() {
case reflect.Int, reflect.Int64, reflect.Int32, reflect.Int16, reflect.Int8,
reflect.Uint64, reflect.Uint32, reflect.Uint16, reflect.Uint8:
return uint8(sv.Int()), nil
}
case INT2:
switch sv.Kind() {
case reflect.Int, reflect.Int64, reflect.Int32, reflect.Int16, reflect.Int8,
reflect.Uint64, reflect.Uint32, reflect.Uint16, reflect.Uint8:
return int16(sv.Int()), nil
}
case INT4:
switch sv.Kind() {
case reflect.Int, reflect.Int64, reflect.Int32, reflect.Int16, reflect.Int8,
reflect.Uint64, reflect.Uint32, reflect.Uint16, reflect.Uint8:
return int32(sv.Int()), nil
}
case INT8, INTN:
switch sv.Kind() {
case reflect.Int, reflect.Int64, reflect.Int32, reflect.Int16, reflect.Int8,
reflect.Uint64, reflect.Uint32, reflect.Uint16, reflect.Uint8:
return sv.Int(), nil
}
case UINT2:
switch sv.Kind() {
case reflect.Int, reflect.Int64, reflect.Int32, reflect.Int16, reflect.Int8,
reflect.Uint64, reflect.Uint32, reflect.Uint16, reflect.Uint8:
return uint16(sv.Uint()), nil
}
case UINT4:
switch sv.Kind() {
case reflect.Int, reflect.Int64, reflect.Int32, reflect.Int16, reflect.Int8,
reflect.Uint64, reflect.Uint32, reflect.Uint16, reflect.Uint8:
return uint32(sv.Uint()), nil
}
case UINT8, UINTN:
switch sv.Kind() {
case reflect.Int, reflect.Int64, reflect.Int32, reflect.Int16, reflect.Int8,
reflect.Uint64, reflect.Uint32, reflect.Uint16, reflect.Uint8:
return sv.Uint(), nil
}
case FLT4:
switch sv.Kind() {
case reflect.Float64:
return float32(sv.Float()), nil
}
case FLT8:
switch sv.Kind() {
case reflect.Float32:
return sv.Float(), nil
}
}
return nil, fmt.Errorf("cannot convert %v (type %T) for %s", v, v, t)
} | asetypes/convert.go | 0.669961 | 0.475423 | convert.go | starcoder |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.