IsComplex

Documentation

Index

• type BasicInfo
• type BasicKind
• type Complex64Pile
  • func MakeComplex64Pile(size, buff int) *Complex64Pile
  • func (d *Complex64Pile) Close() (err error)
  • func (d *Complex64Pile) Done() (done <-chan []complex64)
  • func (d *Complex64Pile) Iter() (item complex64, ok bool)
  • func (d *Complex64Pile) Next() (item complex64, ok bool)
  • func (d *Complex64Pile) Pile(item complex64)
• type Pile
  • func MakePile(size, buff int) *Pile
  • func (d *Pile) Close() (err error)
  • func (d *Pile) Done() (done <-chan []complex128)
  • func (d *Pile) Iter() (item complex128, ok bool)
  • func (d *Pile) Next() (item complex128, ok bool)
  • func (d *Pile) Pile(item complex128)

Types

type BasicInfo

type BasicInfo int

BasicInfo is a set of flags describing properties of a basic type.

const (
	IsBoolean BasicInfo = 1 << iota
	IsInteger
	IsUnsigned
	IsFloat
	IsComplex
	IsString
	IsUntyped

	IsOrdered   = IsInteger | IsFloat | IsString
	IsNumeric   = IsInteger | IsFloat | IsComplex
	IsConstType = IsBoolean | IsNumeric | IsString
)

Properties of basic types.

type BasicKind

type BasicKind int

BasicKind describes the kind of basic type.

type Complex64Pile

type Complex64Pile struct {
	// contains filtered or unexported fields
}

Complex64Pile is a hybrid container for a lazily and concurrently populated growing-only slice of items (of type `complex64`) which may be traversed in parallel to it's growth.

Usage for a pile `p`:

p := MakeComplex64Pile(128, 32)

Have it grow concurrently using multiple:

var item complex64 = something
p.Pile(item)

in as many go routines as You may seem fit.

In parallel, You may either traverse `p` in parallel right away:

for item, ok := p.Iter(); ok; item, ok = p.Next() { ... do sth with item ... }

Here p.Iter() starts a new transversal with the first item (if any), and p.Next() keeps traverses the Complex64Pile.

or traverse blocking / awaiting close first:

for item := range <-p.Done() { ... do sth with item ... }

or use the result when available:

r, p := <-p.Done(), nil

Hint: here we get the result in `r` and at the same time discard / deallocate / forget the pile `p` itself.

Note: The traversal is *not* intended to be concurrency safe! Thus: You may call `Pile` concurrently to Your traversal, but use of either `Done` or `Iter` and `Next` *must* be confined to a single go routine (thread).

func MakeComplex64Pile

func MakeComplex64Pile(size, buff int) *Complex64Pile

MakeComplex64Pile returns a (pointer to a) fresh pile of items (of type `complex64`) with size as initial capacity and with buff as initial leeway, allowing as many Pile's to execute non-blocking before respective Done or Next's.

func (*Complex64Pile) Close

func (d *Complex64Pile) Close() (err error)

Close - call once when everything has been piled.

Close intentionally implements io.Closer

Note: After Close(), any Close(...) will panic and any Pile(...) will panic and any Done() or Next() will return immediately: no eventual blocking, that is.

func (*Complex64Pile) Done

func (d *Complex64Pile) Done() (done <-chan []complex64)

Done returns a channel which emits the result (as slice of Complex64) once the pile is closed.

Users of Done() *must not* iterate (via Iter() Next()...) before the done-channel is closed!

Done is a convenience - useful iff You do not like/need to start any traversal before the pile is fully populated. Once the pile is closed, Done() will signal in constant time.

Note: Upon signalling, the pile is reset to it's tip, so You may traverse it (via Next) right away. Usage for a pile `p`: Traverse blocking / awaiting close first:

for item := range <-p.Done() { ... do sth with item ... }

or use the result when available

r, p := <-p.Done(), nil

while discaring the pile itself.

func (*Complex64Pile) Iter

func (d *Complex64Pile) Iter() (item complex64, ok bool)

Iter puts the pile iterator back to the beginning and returns the first `Next()`, iff any. Usage for a pile `p`:

for item, ok := p.Iter(); ok; item, ok = p.Next() { ... do sth with item ... }

func (*Complex64Pile) Next

func (d *Complex64Pile) Next() (item complex64, ok bool)

Next returns the next item, or false iff the pile is exhausted.

Note: Iff the pile is not closed yet, Next may block, awaiting some Pile().

func (*Complex64Pile) Pile

func (d *Complex64Pile) Pile(item complex64)

Pile appends an `complex64` item to the Complex64Pile.

Note: Pile will block iff buff is exceeded and no Done() or Next()'s are used.

type Pile

type Pile struct {
	// contains filtered or unexported fields
}

Pile is a hybrid container for a lazily and concurrently populated growing-only slice of items (of type `complex128`) which may be traversed in parallel to it's growth.

Usage for a pile `p`:

p := MakePile(128, 32)

Have it grow concurrently using multiple:

var item complex128 = something
p.Pile(item)

in as many go routines as You may seem fit.

In parallel, You may either traverse `p` in parallel right away:

for item, ok := p.Iter(); ok; item, ok = p.Next() { ... do sth with item ... }

Here p.Iter() starts a new transversal with the first item (if any), and p.Next() keeps traverses the Pile.

or traverse blocking / awaiting close first:

for item := range <-p.Done() { ... do sth with item ... }

or use the result when available:

r, p := <-p.Done(), nil

Hint: here we get the result in `r` and at the same time discard / deallocate / forget the pile `p` itself.

Note: The traversal is *not* intended to be concurrency safe! Thus: You may call `Pile` concurrently to Your traversal, but use of either `Done` or `Iter` and `Next` *must* be confined to a single go routine (thread).

func MakePile

func MakePile(size, buff int) *Pile

MakePile returns a (pointer to a) fresh pile of items (of type `complex128`) with size as initial capacity and with buff as initial leeway, allowing as many Pile's to execute non-blocking before respective Done or Next's.

func (*Pile) Close

func (d *Pile) Close() (err error)

Close - call once when everything has been piled.

Close intentionally implements io.Closer

Note: After Close(), any Close(...) will panic and any Pile(...) will panic and any Done() or Next() will return immediately: no eventual blocking, that is.

func (*Pile) Done

func (d *Pile) Done() (done <-chan []complex128)

Done returns a channel which emits the result (as slice of ) once the pile is closed.

Users of Done() *must not* iterate (via Iter() Next()...) before the done-channel is closed!

Done is a convenience - useful iff You do not like/need to start any traversal before the pile is fully populated. Once the pile is closed, Done() will signal in constant time.

Note: Upon signalling, the pile is reset to it's tip, so You may traverse it (via Next) right away. Usage for a pile `p`: Traverse blocking / awaiting close first:

for item := range <-p.Done() { ... do sth with item ... }

or use the result when available

r, p := <-p.Done(), nil

while discaring the pile itself.

func (*Pile) Iter

func (d *Pile) Iter() (item complex128, ok bool)

Iter puts the pile iterator back to the beginning and returns the first `Next()`, iff any. Usage for a pile `p`:

for item, ok := p.Iter(); ok; item, ok = p.Next() { ... do sth with item ... }

func (*Pile) Next

func (d *Pile) Next() (item complex128, ok bool)

Next returns the next item, or false iff the pile is exhausted.

Note: Iff the pile is not closed yet, Next may block, awaiting some Pile().

func (*Pile) Pile

func (d *Pile) Pile(item complex128)

Pile appends an `complex128` item to the Pile.

Note: Pile will block iff buff is exceeded and no Done() or Next()'s are used.