1. update clientset, deepcopy using code-generator
2. add a dummy file tools.go to force "go mod vendor" to see code-generator as dependencies 3. add a script to update CRD 4. add a README to document CRD updating steps run go mod tidy update README
This commit is contained in:
xiangqian
89
vendor/gonum.org/v1/gonum/AUTHORS
generated
vendored
Normal file
89
vendor/gonum.org/v1/gonum/AUTHORS
generated
vendored
Normal file
@@ -0,0 +1,89 @@
|
||||
# This is the official list of gonum authors for copyright purposes.
|
||||
# This file is distinct from the CONTRIBUTORS files.
|
||||
# See the latter for an explanation.
|
||||
|
||||
# Names should be added to this file as
|
||||
# Name or Organization <email address>
|
||||
# The email address is not required for organizations.
|
||||
|
||||
# Please keep the list sorted.
|
||||
|
||||
Alexander Egurnov <alexander.egurnov@gmail.com>
|
||||
Bill Gray <wgray@gogray.com>
|
||||
Bill Noon <noon.bill@gmail.com>
|
||||
Brendan Tracey <tracey.brendan@gmail.com>
|
||||
Brent Pedersen <bpederse@gmail.com>
|
||||
Chad Kunde <kunde21@gmail.com>
|
||||
Chih-Wei Chang <bert.cwchang@gmail.com>
|
||||
Chris Tessum <ctessum@gmail.com>
|
||||
Christophe Meessen <christophe.meessen@gmail.com>
|
||||
Clayton Northey <clayton.northey@gmail.com>
|
||||
Dan Kortschak <dan.kortschak@adelaide.edu.au> <dan@kortschak.io>
|
||||
Daniel Fireman <danielfireman@gmail.com>
|
||||
David Samborski <bloggingarrow@gmail.com>
|
||||
Davor Kapsa <davor.kapsa@gmail.com>
|
||||
DeepMind Technologies
|
||||
Dezmond Goff <goff.dezmond@gmail.com>
|
||||
Egon Elbre <egonelbre@gmail.com>
|
||||
Ekaterina Efimova <katerina.efimova@gmail.com>
|
||||
Ethan Burns <burns.ethan@gmail.com>
|
||||
Evert Lammerts <evert.lammerts@gmail.com>
|
||||
Facundo Gaich <facugaich@gmail.com>
|
||||
Fazlul Shahriar <fshahriar@gmail.com>
|
||||
Francesc Campoy <campoy@golang.org>
|
||||
Google Inc
|
||||
Gustaf Johansson <gustaf@pinon.se>
|
||||
Iakov Davydov <iakov.davydov@unil.ch>
|
||||
Igor Mikushkin <igor.mikushkin@gmail.com>
|
||||
Iskander Sharipov <quasilyte@gmail.com>
|
||||
Jalem Raj Rohit <jrajrohit33@gmail.com>
|
||||
James Bell <james@stellentus.com>
|
||||
James Bowman <james.edward.bowman@gmail.com>
|
||||
James Holmes <32bitkid@gmail.com>
|
||||
Janne Snabb <snabb@epipe.com>
|
||||
Jeff Juozapaitis <jjjuozap@email.arizona.edu>
|
||||
Jeremy Atkinson <jchatkinson@gmail.com>
|
||||
Jonas Kahler <jonas@derkahler.de>
|
||||
Jonas Schulze <jonas.schulze@ovgu.de>
|
||||
Jonathan J Lawlor <jonathan.lawlor@gmail.com>
|
||||
Jonathan Schroeder <jd.schroeder@gmail.com>
|
||||
Joseph Watson <jtwatson@linux-consulting.us>
|
||||
Josh Wilson <josh.craig.wilson@gmail.com>
|
||||
Julien Roland <juroland@gmail.com>
|
||||
Kai Trukenmüller <ktye78@gmail.com>
|
||||
Kent English <kent.english@gmail.com>
|
||||
Kevin C. Zimmerman <kevinczimmerman@gmail.com>
|
||||
Kirill Motkov <motkov.kirill@gmail.com>
|
||||
Konstantin Shaposhnikov <k.shaposhnikov@gmail.com>
|
||||
Leonid Kneller <recondite.matter@gmail.com>
|
||||
Lyron Winderbaum <lyron.winderbaum@student.adelaide.edu.au>
|
||||
Martin Diz <github@martindiz.com.ar>
|
||||
Matthieu Di Mercurio <matthieu.dimercurio@gmail.com>
|
||||
Max Halford <maxhalford25@gmail.com>
|
||||
MinJae Kwon <k239507@gmail.com>
|
||||
Nick Potts <nick@the-potts.com>
|
||||
Olivier Wulveryck <olivier.wulveryck@gmail.com>
|
||||
Or Rikon <rikonor@gmail.com>
|
||||
Pontus Melke <pontusmelke@gmail.com>
|
||||
Renée French
|
||||
Rishi Desai <desai.rishi1@gmail.com>
|
||||
Robin Eklind <r.eklind.87@gmail.com>
|
||||
Sam Zaydel <szaydel@gmail.com>
|
||||
Samuel Kelemen <Samuel@Kelemen.us>
|
||||
Saran Ahluwalia <ahlusar.ahluwalia@gmail.com>
|
||||
Scott Holden <scott@sshconnection.com>
|
||||
Sebastien Binet <seb.binet@gmail.com>
|
||||
Shawn Smith <shawnpsmith@gmail.com>
|
||||
source{d} <hello@sourced.tech>
|
||||
Spencer Lyon <spencerlyon2@gmail.com>
|
||||
Steve McCoy <mccoyst@gmail.com>
|
||||
Taesu Pyo <pyotaesu@gmail.com>
|
||||
Takeshi Yoneda <cz.rk.t0415y.g@gmail.com>
|
||||
The University of Adelaide
|
||||
The University of Minnesota
|
||||
The University of Washington
|
||||
Thomas Berg <tomfuture@gmail.com>
|
||||
Tobin Harding <me@tobin.cc>
|
||||
Vincent Thiery <vjmthiery@gmail.com>
|
||||
Vladimír Chalupecký <vladimir.chalupecky@gmail.com>
|
||||
Yevgeniy Vahlis <evahlis@gmail.com>
|
||||
91
vendor/gonum.org/v1/gonum/CONTRIBUTORS
generated
vendored
Normal file
91
vendor/gonum.org/v1/gonum/CONTRIBUTORS
generated
vendored
Normal file
@@ -0,0 +1,91 @@
|
||||
# This is the official list of people who can contribute
|
||||
# (and typically have contributed) code to the gonum
|
||||
# repository.
|
||||
#
|
||||
# The AUTHORS file lists the copyright holders; this file
|
||||
# lists people. For example, Google employees would be listed here
|
||||
# but not in AUTHORS, because Google would hold the copyright.
|
||||
#
|
||||
# When adding J Random Contributor's name to this file,
|
||||
# either J's name or J's organization's name should be
|
||||
# added to the AUTHORS file.
|
||||
#
|
||||
# Names should be added to this file like so:
|
||||
# Name <email address>
|
||||
#
|
||||
# Please keep the list sorted.
|
||||
|
||||
Alexander Egurnov <alexander.egurnov@gmail.com>
|
||||
Andrew Brampton <brampton@gmail.com>
|
||||
Bill Gray <wgray@gogray.com>
|
||||
Bill Noon <noon.bill@gmail.com>
|
||||
Brendan Tracey <tracey.brendan@gmail.com>
|
||||
Brent Pedersen <bpederse@gmail.com>
|
||||
Chad Kunde <kunde21@gmail.com>
|
||||
Chih-Wei Chang <bert.cwchang@gmail.com>
|
||||
Chris Tessum <ctessum@gmail.com>
|
||||
Christophe Meessen <christophe.meessen@gmail.com>
|
||||
Clayton Northey <clayton.northey@gmail.com>
|
||||
Dan Kortschak <dan.kortschak@adelaide.edu.au> <dan@kortschak.io>
|
||||
Daniel Fireman <danielfireman@gmail.com>
|
||||
David Samborski <bloggingarrow@gmail.com>
|
||||
Davor Kapsa <davor.kapsa@gmail.com>
|
||||
Dezmond Goff <goff.dezmond@gmail.com>
|
||||
Egon Elbre <egonelbre@gmail.com>
|
||||
Ekaterina Efimova <katerina.efimova@gmail.com>
|
||||
Ethan Burns <burns.ethan@gmail.com>
|
||||
Evert Lammerts <evert.lammerts@gmail.com>
|
||||
Facundo Gaich <facugaich@gmail.com>
|
||||
Fazlul Shahriar <fshahriar@gmail.com>
|
||||
Francesc Campoy <campoy@golang.org>
|
||||
Gustaf Johansson <gustaf@pinon.se>
|
||||
Iakov Davydov <iakov.davydov@unil.ch>
|
||||
Igor Mikushkin <igor.mikushkin@gmail.com>
|
||||
Iskander Sharipov <quasilyte@gmail.com>
|
||||
Jalem Raj Rohit <jrajrohit33@gmail.com>
|
||||
James Bell <james@stellentus.com>
|
||||
James Bowman <james.edward.bowman@gmail.com>
|
||||
James Holmes <32bitkid@gmail.com>
|
||||
Janne Snabb <snabb@epipe.com>
|
||||
Jeff Juozapaitis <jjjuozap@email.arizona.edu>
|
||||
Jeremy Atkinson <jchatkinson@gmail.com>
|
||||
Jonas Kahler <jonas@derkahler.de>
|
||||
Jonas Schulze <jonas.schulze@ovgu.de>
|
||||
Jonathan J Lawlor <jonathan.lawlor@gmail.com>
|
||||
Jonathan Schroeder <jd.schroeder@gmail.com>
|
||||
Joseph Watson <jtwatson@linux-consulting.us>
|
||||
Josh Wilson <josh.craig.wilson@gmail.com>
|
||||
Julien Roland <juroland@gmail.com>
|
||||
Kai Trukenmüller <ktye78@gmail.com>
|
||||
Kent English <kent.english@gmail.com>
|
||||
Kevin C. Zimmerman <kevinczimmerman@gmail.com>
|
||||
Kirill Motkov <motkov.kirill@gmail.com>
|
||||
Konstantin Shaposhnikov <k.shaposhnikov@gmail.com>
|
||||
Leonid Kneller <recondite.matter@gmail.com>
|
||||
Lyron Winderbaum <lyron.winderbaum@student.adelaide.edu.au>
|
||||
Martin Diz <github@martindiz.com.ar>
|
||||
Matthieu Di Mercurio <matthieu.dimercurio@gmail.com>
|
||||
Max Halford <maxhalford25@gmail.com>
|
||||
MinJae Kwon <k239507@gmail.com>
|
||||
Nick Potts <nick@the-potts.com>
|
||||
Olivier Wulveryck <olivier.wulveryck@gmail.com>
|
||||
Or Rikon <rikonor@gmail.com>
|
||||
Pontus Melke <pontusmelke@gmail.com>
|
||||
Renée French
|
||||
Rishi Desai <desai.rishi1@gmail.com>
|
||||
Robin Eklind <r.eklind.87@gmail.com>
|
||||
Sam Zaydel <szaydel@gmail.com>
|
||||
Samuel Kelemen <Samuel@Kelemen.us>
|
||||
Saran Ahluwalia <ahlusar.ahluwalia@gmail.com>
|
||||
Scott Holden <scott@sshconnection.com>
|
||||
Sebastien Binet <seb.binet@gmail.com>
|
||||
Shawn Smith <shawnpsmith@gmail.com>
|
||||
Spencer Lyon <spencerlyon2@gmail.com>
|
||||
Steve McCoy <mccoyst@gmail.com>
|
||||
Taesu Pyo <pyotaesu@gmail.com>
|
||||
Takeshi Yoneda <cz.rk.t0415y.g@gmail.com>
|
||||
Thomas Berg <tomfuture@gmail.com>
|
||||
Tobin Harding <me@tobin.cc>
|
||||
Vincent Thiery <vjmthiery@gmail.com>
|
||||
Vladimír Chalupecký <vladimir.chalupecky@gmail.com>
|
||||
Yevgeniy Vahlis <evahlis@gmail.com>
|
||||
23
vendor/gonum.org/v1/gonum/LICENSE
generated
vendored
Normal file
23
vendor/gonum.org/v1/gonum/LICENSE
generated
vendored
Normal file
@@ -0,0 +1,23 @@
|
||||
Copyright ©2013 The Gonum Authors. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
* Neither the name of the gonum project nor the names of its authors and
|
||||
contributors may be used to endorse or promote products derived from this
|
||||
software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
|
||||
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
||||
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
||||
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
47
vendor/gonum.org/v1/gonum/blas/README.md
generated
vendored
Normal file
47
vendor/gonum.org/v1/gonum/blas/README.md
generated
vendored
Normal file
@@ -0,0 +1,47 @@
|
||||
# Gonum BLAS [](https://godoc.org/gonum.org/v1/gonum/blas)
|
||||
|
||||
A collection of packages to provide BLAS functionality for the [Go programming
|
||||
language](http://golang.org)
|
||||
|
||||
## Installation
|
||||
```sh
|
||||
go get gonum.org/v1/gonum/blas/...
|
||||
```
|
||||
|
||||
## Packages
|
||||
|
||||
### blas
|
||||
|
||||
Defines [BLAS API](http://www.netlib.org/blas/blast-forum/cinterface.pdf) split in several
|
||||
interfaces.
|
||||
|
||||
### blas/gonum
|
||||
|
||||
Go implementation of the BLAS API (incomplete, implements the `float32` and `float64` API).
|
||||
|
||||
### blas/blas64 and blas/blas32
|
||||
|
||||
Wrappers for an implementation of the double (i.e., `float64`) and single (`float32`)
|
||||
precision real parts of the BLAS API.
|
||||
|
||||
```Go
|
||||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"gonum.org/v1/gonum/blas/blas64"
|
||||
)
|
||||
|
||||
func main() {
|
||||
v := blas64.Vector{Inc: 1, Data: []float64{1, 1, 1}}
|
||||
fmt.Println("v has length:", blas64.Nrm2(len(v.Data), v))
|
||||
}
|
||||
```
|
||||
|
||||
### blas/cblas128 and blas/cblas64
|
||||
|
||||
Wrappers for an implementation of the double (i.e., `complex128`) and single (`complex64`)
|
||||
precision complex parts of the blas API.
|
||||
|
||||
Currently blas/cblas64 and blas/cblas128 require gonum.org/v1/netlib/blas.
|
||||
283
vendor/gonum.org/v1/gonum/blas/blas.go
generated
vendored
Normal file
283
vendor/gonum.org/v1/gonum/blas/blas.go
generated
vendored
Normal file
@@ -0,0 +1,283 @@
|
||||
// Copyright ©2013 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
//go:generate ./conversions.bash
|
||||
|
||||
package blas
|
||||
|
||||
// Flag constants indicate Givens transformation H matrix state.
|
||||
type Flag int
|
||||
|
||||
const (
|
||||
Identity Flag = -2 // H is the identity matrix; no rotation is needed.
|
||||
Rescaling Flag = -1 // H specifies rescaling.
|
||||
OffDiagonal Flag = 0 // Off-diagonal elements of H are non-unit.
|
||||
Diagonal Flag = 1 // Diagonal elements of H are non-unit.
|
||||
)
|
||||
|
||||
// SrotmParams contains Givens transformation parameters returned
|
||||
// by the Float32 Srotm method.
|
||||
type SrotmParams struct {
|
||||
Flag
|
||||
H [4]float32 // Column-major 2 by 2 matrix.
|
||||
}
|
||||
|
||||
// DrotmParams contains Givens transformation parameters returned
|
||||
// by the Float64 Drotm method.
|
||||
type DrotmParams struct {
|
||||
Flag
|
||||
H [4]float64 // Column-major 2 by 2 matrix.
|
||||
}
|
||||
|
||||
// Transpose specifies the transposition operation of a matrix.
|
||||
type Transpose byte
|
||||
|
||||
const (
|
||||
NoTrans Transpose = 'N'
|
||||
Trans Transpose = 'T'
|
||||
ConjTrans Transpose = 'C'
|
||||
)
|
||||
|
||||
// Uplo specifies whether a matrix is upper or lower triangular.
|
||||
type Uplo byte
|
||||
|
||||
const (
|
||||
Upper Uplo = 'U'
|
||||
Lower Uplo = 'L'
|
||||
All Uplo = 'A'
|
||||
)
|
||||
|
||||
// Diag specifies whether a matrix is unit triangular.
|
||||
type Diag byte
|
||||
|
||||
const (
|
||||
NonUnit Diag = 'N'
|
||||
Unit Diag = 'U'
|
||||
)
|
||||
|
||||
// Side specifies from which side a multiplication operation is performed.
|
||||
type Side byte
|
||||
|
||||
const (
|
||||
Left Side = 'L'
|
||||
Right Side = 'R'
|
||||
)
|
||||
|
||||
// Float32 implements the single precision real BLAS routines.
|
||||
type Float32 interface {
|
||||
Float32Level1
|
||||
Float32Level2
|
||||
Float32Level3
|
||||
}
|
||||
|
||||
// Float32Level1 implements the single precision real BLAS Level 1 routines.
|
||||
type Float32Level1 interface {
|
||||
Sdsdot(n int, alpha float32, x []float32, incX int, y []float32, incY int) float32
|
||||
Dsdot(n int, x []float32, incX int, y []float32, incY int) float64
|
||||
Sdot(n int, x []float32, incX int, y []float32, incY int) float32
|
||||
Snrm2(n int, x []float32, incX int) float32
|
||||
Sasum(n int, x []float32, incX int) float32
|
||||
Isamax(n int, x []float32, incX int) int
|
||||
Sswap(n int, x []float32, incX int, y []float32, incY int)
|
||||
Scopy(n int, x []float32, incX int, y []float32, incY int)
|
||||
Saxpy(n int, alpha float32, x []float32, incX int, y []float32, incY int)
|
||||
Srotg(a, b float32) (c, s, r, z float32)
|
||||
Srotmg(d1, d2, b1, b2 float32) (p SrotmParams, rd1, rd2, rb1 float32)
|
||||
Srot(n int, x []float32, incX int, y []float32, incY int, c, s float32)
|
||||
Srotm(n int, x []float32, incX int, y []float32, incY int, p SrotmParams)
|
||||
Sscal(n int, alpha float32, x []float32, incX int)
|
||||
}
|
||||
|
||||
// Float32Level2 implements the single precision real BLAS Level 2 routines.
|
||||
type Float32Level2 interface {
|
||||
Sgemv(tA Transpose, m, n int, alpha float32, a []float32, lda int, x []float32, incX int, beta float32, y []float32, incY int)
|
||||
Sgbmv(tA Transpose, m, n, kL, kU int, alpha float32, a []float32, lda int, x []float32, incX int, beta float32, y []float32, incY int)
|
||||
Strmv(ul Uplo, tA Transpose, d Diag, n int, a []float32, lda int, x []float32, incX int)
|
||||
Stbmv(ul Uplo, tA Transpose, d Diag, n, k int, a []float32, lda int, x []float32, incX int)
|
||||
Stpmv(ul Uplo, tA Transpose, d Diag, n int, ap []float32, x []float32, incX int)
|
||||
Strsv(ul Uplo, tA Transpose, d Diag, n int, a []float32, lda int, x []float32, incX int)
|
||||
Stbsv(ul Uplo, tA Transpose, d Diag, n, k int, a []float32, lda int, x []float32, incX int)
|
||||
Stpsv(ul Uplo, tA Transpose, d Diag, n int, ap []float32, x []float32, incX int)
|
||||
Ssymv(ul Uplo, n int, alpha float32, a []float32, lda int, x []float32, incX int, beta float32, y []float32, incY int)
|
||||
Ssbmv(ul Uplo, n, k int, alpha float32, a []float32, lda int, x []float32, incX int, beta float32, y []float32, incY int)
|
||||
Sspmv(ul Uplo, n int, alpha float32, ap []float32, x []float32, incX int, beta float32, y []float32, incY int)
|
||||
Sger(m, n int, alpha float32, x []float32, incX int, y []float32, incY int, a []float32, lda int)
|
||||
Ssyr(ul Uplo, n int, alpha float32, x []float32, incX int, a []float32, lda int)
|
||||
Sspr(ul Uplo, n int, alpha float32, x []float32, incX int, ap []float32)
|
||||
Ssyr2(ul Uplo, n int, alpha float32, x []float32, incX int, y []float32, incY int, a []float32, lda int)
|
||||
Sspr2(ul Uplo, n int, alpha float32, x []float32, incX int, y []float32, incY int, a []float32)
|
||||
}
|
||||
|
||||
// Float32Level3 implements the single precision real BLAS Level 3 routines.
|
||||
type Float32Level3 interface {
|
||||
Sgemm(tA, tB Transpose, m, n, k int, alpha float32, a []float32, lda int, b []float32, ldb int, beta float32, c []float32, ldc int)
|
||||
Ssymm(s Side, ul Uplo, m, n int, alpha float32, a []float32, lda int, b []float32, ldb int, beta float32, c []float32, ldc int)
|
||||
Ssyrk(ul Uplo, t Transpose, n, k int, alpha float32, a []float32, lda int, beta float32, c []float32, ldc int)
|
||||
Ssyr2k(ul Uplo, t Transpose, n, k int, alpha float32, a []float32, lda int, b []float32, ldb int, beta float32, c []float32, ldc int)
|
||||
Strmm(s Side, ul Uplo, tA Transpose, d Diag, m, n int, alpha float32, a []float32, lda int, b []float32, ldb int)
|
||||
Strsm(s Side, ul Uplo, tA Transpose, d Diag, m, n int, alpha float32, a []float32, lda int, b []float32, ldb int)
|
||||
}
|
||||
|
||||
// Float64 implements the single precision real BLAS routines.
|
||||
type Float64 interface {
|
||||
Float64Level1
|
||||
Float64Level2
|
||||
Float64Level3
|
||||
}
|
||||
|
||||
// Float64Level1 implements the double precision real BLAS Level 1 routines.
|
||||
type Float64Level1 interface {
|
||||
Ddot(n int, x []float64, incX int, y []float64, incY int) float64
|
||||
Dnrm2(n int, x []float64, incX int) float64
|
||||
Dasum(n int, x []float64, incX int) float64
|
||||
Idamax(n int, x []float64, incX int) int
|
||||
Dswap(n int, x []float64, incX int, y []float64, incY int)
|
||||
Dcopy(n int, x []float64, incX int, y []float64, incY int)
|
||||
Daxpy(n int, alpha float64, x []float64, incX int, y []float64, incY int)
|
||||
Drotg(a, b float64) (c, s, r, z float64)
|
||||
Drotmg(d1, d2, b1, b2 float64) (p DrotmParams, rd1, rd2, rb1 float64)
|
||||
Drot(n int, x []float64, incX int, y []float64, incY int, c float64, s float64)
|
||||
Drotm(n int, x []float64, incX int, y []float64, incY int, p DrotmParams)
|
||||
Dscal(n int, alpha float64, x []float64, incX int)
|
||||
}
|
||||
|
||||
// Float64Level2 implements the double precision real BLAS Level 2 routines.
|
||||
type Float64Level2 interface {
|
||||
Dgemv(tA Transpose, m, n int, alpha float64, a []float64, lda int, x []float64, incX int, beta float64, y []float64, incY int)
|
||||
Dgbmv(tA Transpose, m, n, kL, kU int, alpha float64, a []float64, lda int, x []float64, incX int, beta float64, y []float64, incY int)
|
||||
Dtrmv(ul Uplo, tA Transpose, d Diag, n int, a []float64, lda int, x []float64, incX int)
|
||||
Dtbmv(ul Uplo, tA Transpose, d Diag, n, k int, a []float64, lda int, x []float64, incX int)
|
||||
Dtpmv(ul Uplo, tA Transpose, d Diag, n int, ap []float64, x []float64, incX int)
|
||||
Dtrsv(ul Uplo, tA Transpose, d Diag, n int, a []float64, lda int, x []float64, incX int)
|
||||
Dtbsv(ul Uplo, tA Transpose, d Diag, n, k int, a []float64, lda int, x []float64, incX int)
|
||||
Dtpsv(ul Uplo, tA Transpose, d Diag, n int, ap []float64, x []float64, incX int)
|
||||
Dsymv(ul Uplo, n int, alpha float64, a []float64, lda int, x []float64, incX int, beta float64, y []float64, incY int)
|
||||
Dsbmv(ul Uplo, n, k int, alpha float64, a []float64, lda int, x []float64, incX int, beta float64, y []float64, incY int)
|
||||
Dspmv(ul Uplo, n int, alpha float64, ap []float64, x []float64, incX int, beta float64, y []float64, incY int)
|
||||
Dger(m, n int, alpha float64, x []float64, incX int, y []float64, incY int, a []float64, lda int)
|
||||
Dsyr(ul Uplo, n int, alpha float64, x []float64, incX int, a []float64, lda int)
|
||||
Dspr(ul Uplo, n int, alpha float64, x []float64, incX int, ap []float64)
|
||||
Dsyr2(ul Uplo, n int, alpha float64, x []float64, incX int, y []float64, incY int, a []float64, lda int)
|
||||
Dspr2(ul Uplo, n int, alpha float64, x []float64, incX int, y []float64, incY int, a []float64)
|
||||
}
|
||||
|
||||
// Float64Level3 implements the double precision real BLAS Level 3 routines.
|
||||
type Float64Level3 interface {
|
||||
Dgemm(tA, tB Transpose, m, n, k int, alpha float64, a []float64, lda int, b []float64, ldb int, beta float64, c []float64, ldc int)
|
||||
Dsymm(s Side, ul Uplo, m, n int, alpha float64, a []float64, lda int, b []float64, ldb int, beta float64, c []float64, ldc int)
|
||||
Dsyrk(ul Uplo, t Transpose, n, k int, alpha float64, a []float64, lda int, beta float64, c []float64, ldc int)
|
||||
Dsyr2k(ul Uplo, t Transpose, n, k int, alpha float64, a []float64, lda int, b []float64, ldb int, beta float64, c []float64, ldc int)
|
||||
Dtrmm(s Side, ul Uplo, tA Transpose, d Diag, m, n int, alpha float64, a []float64, lda int, b []float64, ldb int)
|
||||
Dtrsm(s Side, ul Uplo, tA Transpose, d Diag, m, n int, alpha float64, a []float64, lda int, b []float64, ldb int)
|
||||
}
|
||||
|
||||
// Complex64 implements the single precision complex BLAS routines.
|
||||
type Complex64 interface {
|
||||
Complex64Level1
|
||||
Complex64Level2
|
||||
Complex64Level3
|
||||
}
|
||||
|
||||
// Complex64Level1 implements the single precision complex BLAS Level 1 routines.
|
||||
type Complex64Level1 interface {
|
||||
Cdotu(n int, x []complex64, incX int, y []complex64, incY int) (dotu complex64)
|
||||
Cdotc(n int, x []complex64, incX int, y []complex64, incY int) (dotc complex64)
|
||||
Scnrm2(n int, x []complex64, incX int) float32
|
||||
Scasum(n int, x []complex64, incX int) float32
|
||||
Icamax(n int, x []complex64, incX int) int
|
||||
Cswap(n int, x []complex64, incX int, y []complex64, incY int)
|
||||
Ccopy(n int, x []complex64, incX int, y []complex64, incY int)
|
||||
Caxpy(n int, alpha complex64, x []complex64, incX int, y []complex64, incY int)
|
||||
Cscal(n int, alpha complex64, x []complex64, incX int)
|
||||
Csscal(n int, alpha float32, x []complex64, incX int)
|
||||
}
|
||||
|
||||
// Complex64Level2 implements the single precision complex BLAS routines Level 2 routines.
|
||||
type Complex64Level2 interface {
|
||||
Cgemv(tA Transpose, m, n int, alpha complex64, a []complex64, lda int, x []complex64, incX int, beta complex64, y []complex64, incY int)
|
||||
Cgbmv(tA Transpose, m, n, kL, kU int, alpha complex64, a []complex64, lda int, x []complex64, incX int, beta complex64, y []complex64, incY int)
|
||||
Ctrmv(ul Uplo, tA Transpose, d Diag, n int, a []complex64, lda int, x []complex64, incX int)
|
||||
Ctbmv(ul Uplo, tA Transpose, d Diag, n, k int, a []complex64, lda int, x []complex64, incX int)
|
||||
Ctpmv(ul Uplo, tA Transpose, d Diag, n int, ap []complex64, x []complex64, incX int)
|
||||
Ctrsv(ul Uplo, tA Transpose, d Diag, n int, a []complex64, lda int, x []complex64, incX int)
|
||||
Ctbsv(ul Uplo, tA Transpose, d Diag, n, k int, a []complex64, lda int, x []complex64, incX int)
|
||||
Ctpsv(ul Uplo, tA Transpose, d Diag, n int, ap []complex64, x []complex64, incX int)
|
||||
Chemv(ul Uplo, n int, alpha complex64, a []complex64, lda int, x []complex64, incX int, beta complex64, y []complex64, incY int)
|
||||
Chbmv(ul Uplo, n, k int, alpha complex64, a []complex64, lda int, x []complex64, incX int, beta complex64, y []complex64, incY int)
|
||||
Chpmv(ul Uplo, n int, alpha complex64, ap []complex64, x []complex64, incX int, beta complex64, y []complex64, incY int)
|
||||
Cgeru(m, n int, alpha complex64, x []complex64, incX int, y []complex64, incY int, a []complex64, lda int)
|
||||
Cgerc(m, n int, alpha complex64, x []complex64, incX int, y []complex64, incY int, a []complex64, lda int)
|
||||
Cher(ul Uplo, n int, alpha float32, x []complex64, incX int, a []complex64, lda int)
|
||||
Chpr(ul Uplo, n int, alpha float32, x []complex64, incX int, a []complex64)
|
||||
Cher2(ul Uplo, n int, alpha complex64, x []complex64, incX int, y []complex64, incY int, a []complex64, lda int)
|
||||
Chpr2(ul Uplo, n int, alpha complex64, x []complex64, incX int, y []complex64, incY int, ap []complex64)
|
||||
}
|
||||
|
||||
// Complex64Level3 implements the single precision complex BLAS Level 3 routines.
|
||||
type Complex64Level3 interface {
|
||||
Cgemm(tA, tB Transpose, m, n, k int, alpha complex64, a []complex64, lda int, b []complex64, ldb int, beta complex64, c []complex64, ldc int)
|
||||
Csymm(s Side, ul Uplo, m, n int, alpha complex64, a []complex64, lda int, b []complex64, ldb int, beta complex64, c []complex64, ldc int)
|
||||
Csyrk(ul Uplo, t Transpose, n, k int, alpha complex64, a []complex64, lda int, beta complex64, c []complex64, ldc int)
|
||||
Csyr2k(ul Uplo, t Transpose, n, k int, alpha complex64, a []complex64, lda int, b []complex64, ldb int, beta complex64, c []complex64, ldc int)
|
||||
Ctrmm(s Side, ul Uplo, tA Transpose, d Diag, m, n int, alpha complex64, a []complex64, lda int, b []complex64, ldb int)
|
||||
Ctrsm(s Side, ul Uplo, tA Transpose, d Diag, m, n int, alpha complex64, a []complex64, lda int, b []complex64, ldb int)
|
||||
Chemm(s Side, ul Uplo, m, n int, alpha complex64, a []complex64, lda int, b []complex64, ldb int, beta complex64, c []complex64, ldc int)
|
||||
Cherk(ul Uplo, t Transpose, n, k int, alpha float32, a []complex64, lda int, beta float32, c []complex64, ldc int)
|
||||
Cher2k(ul Uplo, t Transpose, n, k int, alpha complex64, a []complex64, lda int, b []complex64, ldb int, beta float32, c []complex64, ldc int)
|
||||
}
|
||||
|
||||
// Complex128 implements the double precision complex BLAS routines.
|
||||
type Complex128 interface {
|
||||
Complex128Level1
|
||||
Complex128Level2
|
||||
Complex128Level3
|
||||
}
|
||||
|
||||
// Complex128Level1 implements the double precision complex BLAS Level 1 routines.
|
||||
type Complex128Level1 interface {
|
||||
Zdotu(n int, x []complex128, incX int, y []complex128, incY int) (dotu complex128)
|
||||
Zdotc(n int, x []complex128, incX int, y []complex128, incY int) (dotc complex128)
|
||||
Dznrm2(n int, x []complex128, incX int) float64
|
||||
Dzasum(n int, x []complex128, incX int) float64
|
||||
Izamax(n int, x []complex128, incX int) int
|
||||
Zswap(n int, x []complex128, incX int, y []complex128, incY int)
|
||||
Zcopy(n int, x []complex128, incX int, y []complex128, incY int)
|
||||
Zaxpy(n int, alpha complex128, x []complex128, incX int, y []complex128, incY int)
|
||||
Zscal(n int, alpha complex128, x []complex128, incX int)
|
||||
Zdscal(n int, alpha float64, x []complex128, incX int)
|
||||
}
|
||||
|
||||
// Complex128Level2 implements the double precision complex BLAS Level 2 routines.
|
||||
type Complex128Level2 interface {
|
||||
Zgemv(tA Transpose, m, n int, alpha complex128, a []complex128, lda int, x []complex128, incX int, beta complex128, y []complex128, incY int)
|
||||
Zgbmv(tA Transpose, m, n int, kL int, kU int, alpha complex128, a []complex128, lda int, x []complex128, incX int, beta complex128, y []complex128, incY int)
|
||||
Ztrmv(ul Uplo, tA Transpose, d Diag, n int, a []complex128, lda int, x []complex128, incX int)
|
||||
Ztbmv(ul Uplo, tA Transpose, d Diag, n, k int, a []complex128, lda int, x []complex128, incX int)
|
||||
Ztpmv(ul Uplo, tA Transpose, d Diag, n int, ap []complex128, x []complex128, incX int)
|
||||
Ztrsv(ul Uplo, tA Transpose, d Diag, n int, a []complex128, lda int, x []complex128, incX int)
|
||||
Ztbsv(ul Uplo, tA Transpose, d Diag, n, k int, a []complex128, lda int, x []complex128, incX int)
|
||||
Ztpsv(ul Uplo, tA Transpose, d Diag, n int, ap []complex128, x []complex128, incX int)
|
||||
Zhemv(ul Uplo, n int, alpha complex128, a []complex128, lda int, x []complex128, incX int, beta complex128, y []complex128, incY int)
|
||||
Zhbmv(ul Uplo, n, k int, alpha complex128, a []complex128, lda int, x []complex128, incX int, beta complex128, y []complex128, incY int)
|
||||
Zhpmv(ul Uplo, n int, alpha complex128, ap []complex128, x []complex128, incX int, beta complex128, y []complex128, incY int)
|
||||
Zgeru(m, n int, alpha complex128, x []complex128, incX int, y []complex128, incY int, a []complex128, lda int)
|
||||
Zgerc(m, n int, alpha complex128, x []complex128, incX int, y []complex128, incY int, a []complex128, lda int)
|
||||
Zher(ul Uplo, n int, alpha float64, x []complex128, incX int, a []complex128, lda int)
|
||||
Zhpr(ul Uplo, n int, alpha float64, x []complex128, incX int, a []complex128)
|
||||
Zher2(ul Uplo, n int, alpha complex128, x []complex128, incX int, y []complex128, incY int, a []complex128, lda int)
|
||||
Zhpr2(ul Uplo, n int, alpha complex128, x []complex128, incX int, y []complex128, incY int, ap []complex128)
|
||||
}
|
||||
|
||||
// Complex128Level3 implements the double precision complex BLAS Level 3 routines.
|
||||
type Complex128Level3 interface {
|
||||
Zgemm(tA, tB Transpose, m, n, k int, alpha complex128, a []complex128, lda int, b []complex128, ldb int, beta complex128, c []complex128, ldc int)
|
||||
Zsymm(s Side, ul Uplo, m, n int, alpha complex128, a []complex128, lda int, b []complex128, ldb int, beta complex128, c []complex128, ldc int)
|
||||
Zsyrk(ul Uplo, t Transpose, n, k int, alpha complex128, a []complex128, lda int, beta complex128, c []complex128, ldc int)
|
||||
Zsyr2k(ul Uplo, t Transpose, n, k int, alpha complex128, a []complex128, lda int, b []complex128, ldb int, beta complex128, c []complex128, ldc int)
|
||||
Ztrmm(s Side, ul Uplo, tA Transpose, d Diag, m, n int, alpha complex128, a []complex128, lda int, b []complex128, ldb int)
|
||||
Ztrsm(s Side, ul Uplo, tA Transpose, d Diag, m, n int, alpha complex128, a []complex128, lda int, b []complex128, ldb int)
|
||||
Zhemm(s Side, ul Uplo, m, n int, alpha complex128, a []complex128, lda int, b []complex128, ldb int, beta complex128, c []complex128, ldc int)
|
||||
Zherk(ul Uplo, t Transpose, n, k int, alpha float64, a []complex128, lda int, beta float64, c []complex128, ldc int)
|
||||
Zher2k(ul Uplo, t Transpose, n, k int, alpha complex128, a []complex128, lda int, b []complex128, ldb int, beta float64, c []complex128, ldc int)
|
||||
}
|
||||
469
vendor/gonum.org/v1/gonum/blas/blas64/blas64.go
generated
vendored
Normal file
469
vendor/gonum.org/v1/gonum/blas/blas64/blas64.go
generated
vendored
Normal file
@@ -0,0 +1,469 @@
|
||||
// Copyright ©2015 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package blas64
|
||||
|
||||
import (
|
||||
"gonum.org/v1/gonum/blas"
|
||||
"gonum.org/v1/gonum/blas/gonum"
|
||||
)
|
||||
|
||||
var blas64 blas.Float64 = gonum.Implementation{}
|
||||
|
||||
// Use sets the BLAS float64 implementation to be used by subsequent BLAS calls.
|
||||
// The default implementation is
|
||||
// gonum.org/v1/gonum/blas/gonum.Implementation.
|
||||
func Use(b blas.Float64) {
|
||||
blas64 = b
|
||||
}
|
||||
|
||||
// Implementation returns the current BLAS float64 implementation.
|
||||
//
|
||||
// Implementation allows direct calls to the current the BLAS float64 implementation
|
||||
// giving finer control of parameters.
|
||||
func Implementation() blas.Float64 {
|
||||
return blas64
|
||||
}
|
||||
|
||||
// Vector represents a vector with an associated element increment.
|
||||
type Vector struct {
|
||||
N int
|
||||
Data []float64
|
||||
Inc int
|
||||
}
|
||||
|
||||
// General represents a matrix using the conventional storage scheme.
|
||||
type General struct {
|
||||
Rows, Cols int
|
||||
Data []float64
|
||||
Stride int
|
||||
}
|
||||
|
||||
// Band represents a band matrix using the band storage scheme.
|
||||
type Band struct {
|
||||
Rows, Cols int
|
||||
KL, KU int
|
||||
Data []float64
|
||||
Stride int
|
||||
}
|
||||
|
||||
// Triangular represents a triangular matrix using the conventional storage scheme.
|
||||
type Triangular struct {
|
||||
Uplo blas.Uplo
|
||||
Diag blas.Diag
|
||||
N int
|
||||
Data []float64
|
||||
Stride int
|
||||
}
|
||||
|
||||
// TriangularBand represents a triangular matrix using the band storage scheme.
|
||||
type TriangularBand struct {
|
||||
Uplo blas.Uplo
|
||||
Diag blas.Diag
|
||||
N, K int
|
||||
Data []float64
|
||||
Stride int
|
||||
}
|
||||
|
||||
// TriangularPacked represents a triangular matrix using the packed storage scheme.
|
||||
type TriangularPacked struct {
|
||||
Uplo blas.Uplo
|
||||
Diag blas.Diag
|
||||
N int
|
||||
Data []float64
|
||||
}
|
||||
|
||||
// Symmetric represents a symmetric matrix using the conventional storage scheme.
|
||||
type Symmetric struct {
|
||||
Uplo blas.Uplo
|
||||
N int
|
||||
Data []float64
|
||||
Stride int
|
||||
}
|
||||
|
||||
// SymmetricBand represents a symmetric matrix using the band storage scheme.
|
||||
type SymmetricBand struct {
|
||||
Uplo blas.Uplo
|
||||
N, K int
|
||||
Data []float64
|
||||
Stride int
|
||||
}
|
||||
|
||||
// SymmetricPacked represents a symmetric matrix using the packed storage scheme.
|
||||
type SymmetricPacked struct {
|
||||
Uplo blas.Uplo
|
||||
N int
|
||||
Data []float64
|
||||
}
|
||||
|
||||
// Level 1
|
||||
|
||||
const (
|
||||
negInc = "blas64: negative vector increment"
|
||||
badLength = "blas64: vector length mismatch"
|
||||
)
|
||||
|
||||
// Dot computes the dot product of the two vectors:
|
||||
// \sum_i x[i]*y[i].
|
||||
func Dot(x, y Vector) float64 {
|
||||
if x.N != y.N {
|
||||
panic(badLength)
|
||||
}
|
||||
return blas64.Ddot(x.N, x.Data, x.Inc, y.Data, y.Inc)
|
||||
}
|
||||
|
||||
// Nrm2 computes the Euclidean norm of the vector x:
|
||||
// sqrt(\sum_i x[i]*x[i]).
|
||||
//
|
||||
// Nrm2 will panic if the vector increment is negative.
|
||||
func Nrm2(x Vector) float64 {
|
||||
if x.Inc < 0 {
|
||||
panic(negInc)
|
||||
}
|
||||
return blas64.Dnrm2(x.N, x.Data, x.Inc)
|
||||
}
|
||||
|
||||
// Asum computes the sum of the absolute values of the elements of x:
|
||||
// \sum_i |x[i]|.
|
||||
//
|
||||
// Asum will panic if the vector increment is negative.
|
||||
func Asum(x Vector) float64 {
|
||||
if x.Inc < 0 {
|
||||
panic(negInc)
|
||||
}
|
||||
return blas64.Dasum(x.N, x.Data, x.Inc)
|
||||
}
|
||||
|
||||
// Iamax returns the index of an element of x with the largest absolute value.
|
||||
// If there are multiple such indices the earliest is returned.
|
||||
// Iamax returns -1 if n == 0.
|
||||
//
|
||||
// Iamax will panic if the vector increment is negative.
|
||||
func Iamax(x Vector) int {
|
||||
if x.Inc < 0 {
|
||||
panic(negInc)
|
||||
}
|
||||
return blas64.Idamax(x.N, x.Data, x.Inc)
|
||||
}
|
||||
|
||||
// Swap exchanges the elements of the two vectors:
|
||||
// x[i], y[i] = y[i], x[i] for all i.
|
||||
func Swap(x, y Vector) {
|
||||
if x.N != y.N {
|
||||
panic(badLength)
|
||||
}
|
||||
blas64.Dswap(x.N, x.Data, x.Inc, y.Data, y.Inc)
|
||||
}
|
||||
|
||||
// Copy copies the elements of x into the elements of y:
|
||||
// y[i] = x[i] for all i.
|
||||
// Copy requires that the lengths of x and y match and will panic otherwise.
|
||||
func Copy(x, y Vector) {
|
||||
if x.N != y.N {
|
||||
panic(badLength)
|
||||
}
|
||||
blas64.Dcopy(x.N, x.Data, x.Inc, y.Data, y.Inc)
|
||||
}
|
||||
|
||||
// Axpy adds x scaled by alpha to y:
|
||||
// y[i] += alpha*x[i] for all i.
|
||||
func Axpy(alpha float64, x, y Vector) {
|
||||
if x.N != y.N {
|
||||
panic(badLength)
|
||||
}
|
||||
blas64.Daxpy(x.N, alpha, x.Data, x.Inc, y.Data, y.Inc)
|
||||
}
|
||||
|
||||
// Rotg computes the parameters of a Givens plane rotation so that
|
||||
// ⎡ c s⎤ ⎡a⎤ ⎡r⎤
|
||||
// ⎣-s c⎦ * ⎣b⎦ = ⎣0⎦
|
||||
// where a and b are the Cartesian coordinates of a given point.
|
||||
// c, s, and r are defined as
|
||||
// r = ±Sqrt(a^2 + b^2),
|
||||
// c = a/r, the cosine of the rotation angle,
|
||||
// s = a/r, the sine of the rotation angle,
|
||||
// and z is defined such that
|
||||
// if |a| > |b|, z = s,
|
||||
// otherwise if c != 0, z = 1/c,
|
||||
// otherwise z = 1.
|
||||
func Rotg(a, b float64) (c, s, r, z float64) {
|
||||
return blas64.Drotg(a, b)
|
||||
}
|
||||
|
||||
// Rotmg computes the modified Givens rotation. See
|
||||
// http://www.netlib.org/lapack/explore-html/df/deb/drotmg_8f.html
|
||||
// for more details.
|
||||
func Rotmg(d1, d2, b1, b2 float64) (p blas.DrotmParams, rd1, rd2, rb1 float64) {
|
||||
return blas64.Drotmg(d1, d2, b1, b2)
|
||||
}
|
||||
|
||||
// Rot applies a plane transformation to n points represented by the vectors x
|
||||
// and y:
|
||||
// x[i] = c*x[i] + s*y[i],
|
||||
// y[i] = -s*x[i] + c*y[i], for all i.
|
||||
func Rot(x, y Vector, c, s float64) {
|
||||
if x.N != y.N {
|
||||
panic(badLength)
|
||||
}
|
||||
blas64.Drot(x.N, x.Data, x.Inc, y.Data, y.Inc, c, s)
|
||||
}
|
||||
|
||||
// Rotm applies the modified Givens rotation to n points represented by the
|
||||
// vectors x and y.
|
||||
func Rotm(x, y Vector, p blas.DrotmParams) {
|
||||
if x.N != y.N {
|
||||
panic(badLength)
|
||||
}
|
||||
blas64.Drotm(x.N, x.Data, x.Inc, y.Data, y.Inc, p)
|
||||
}
|
||||
|
||||
// Scal scales the vector x by alpha:
|
||||
// x[i] *= alpha for all i.
|
||||
//
|
||||
// Scal will panic if the vector increment is negative.
|
||||
func Scal(alpha float64, x Vector) {
|
||||
if x.Inc < 0 {
|
||||
panic(negInc)
|
||||
}
|
||||
blas64.Dscal(x.N, alpha, x.Data, x.Inc)
|
||||
}
|
||||
|
||||
// Level 2
|
||||
|
||||
// Gemv computes
|
||||
// y = alpha * A * x + beta * y, if t == blas.NoTrans,
|
||||
// y = alpha * A^T * x + beta * y, if t == blas.Trans or blas.ConjTrans,
|
||||
// where A is an m×n dense matrix, x and y are vectors, and alpha and beta are scalars.
|
||||
func Gemv(t blas.Transpose, alpha float64, a General, x Vector, beta float64, y Vector) {
|
||||
blas64.Dgemv(t, a.Rows, a.Cols, alpha, a.Data, a.Stride, x.Data, x.Inc, beta, y.Data, y.Inc)
|
||||
}
|
||||
|
||||
// Gbmv computes
|
||||
// y = alpha * A * x + beta * y, if t == blas.NoTrans,
|
||||
// y = alpha * A^T * x + beta * y, if t == blas.Trans or blas.ConjTrans,
|
||||
// where A is an m×n band matrix, x and y are vectors, and alpha and beta are scalars.
|
||||
func Gbmv(t blas.Transpose, alpha float64, a Band, x Vector, beta float64, y Vector) {
|
||||
blas64.Dgbmv(t, a.Rows, a.Cols, a.KL, a.KU, alpha, a.Data, a.Stride, x.Data, x.Inc, beta, y.Data, y.Inc)
|
||||
}
|
||||
|
||||
// Trmv computes
|
||||
// x = A * x, if t == blas.NoTrans,
|
||||
// x = A^T * x, if t == blas.Trans or blas.ConjTrans,
|
||||
// where A is an n×n triangular matrix, and x is a vector.
|
||||
func Trmv(t blas.Transpose, a Triangular, x Vector) {
|
||||
blas64.Dtrmv(a.Uplo, t, a.Diag, a.N, a.Data, a.Stride, x.Data, x.Inc)
|
||||
}
|
||||
|
||||
// Tbmv computes
|
||||
// x = A * x, if t == blas.NoTrans,
|
||||
// x = A^T * x, if t == blas.Trans or blas.ConjTrans,
|
||||
// where A is an n×n triangular band matrix, and x is a vector.
|
||||
func Tbmv(t blas.Transpose, a TriangularBand, x Vector) {
|
||||
blas64.Dtbmv(a.Uplo, t, a.Diag, a.N, a.K, a.Data, a.Stride, x.Data, x.Inc)
|
||||
}
|
||||
|
||||
// Tpmv computes
|
||||
// x = A * x, if t == blas.NoTrans,
|
||||
// x = A^T * x, if t == blas.Trans or blas.ConjTrans,
|
||||
// where A is an n×n triangular matrix in packed format, and x is a vector.
|
||||
func Tpmv(t blas.Transpose, a TriangularPacked, x Vector) {
|
||||
blas64.Dtpmv(a.Uplo, t, a.Diag, a.N, a.Data, x.Data, x.Inc)
|
||||
}
|
||||
|
||||
// Trsv solves
|
||||
// A * x = b, if t == blas.NoTrans,
|
||||
// A^T * x = b, if t == blas.Trans or blas.ConjTrans,
|
||||
// where A is an n×n triangular matrix, and x and b are vectors.
|
||||
//
|
||||
// At entry to the function, x contains the values of b, and the result is
|
||||
// stored in-place into x.
|
||||
//
|
||||
// No test for singularity or near-singularity is included in this
|
||||
// routine. Such tests must be performed before calling this routine.
|
||||
func Trsv(t blas.Transpose, a Triangular, x Vector) {
|
||||
blas64.Dtrsv(a.Uplo, t, a.Diag, a.N, a.Data, a.Stride, x.Data, x.Inc)
|
||||
}
|
||||
|
||||
// Tbsv solves
|
||||
// A * x = b, if t == blas.NoTrans,
|
||||
// A^T * x = b, if t == blas.Trans or blas.ConjTrans,
|
||||
// where A is an n×n triangular band matrix, and x and b are vectors.
|
||||
//
|
||||
// At entry to the function, x contains the values of b, and the result is
|
||||
// stored in place into x.
|
||||
//
|
||||
// No test for singularity or near-singularity is included in this
|
||||
// routine. Such tests must be performed before calling this routine.
|
||||
func Tbsv(t blas.Transpose, a TriangularBand, x Vector) {
|
||||
blas64.Dtbsv(a.Uplo, t, a.Diag, a.N, a.K, a.Data, a.Stride, x.Data, x.Inc)
|
||||
}
|
||||
|
||||
// Tpsv solves
|
||||
// A * x = b, if t == blas.NoTrans,
|
||||
// A^T * x = b, if t == blas.Trans or blas.ConjTrans,
|
||||
// where A is an n×n triangular matrix in packed format, and x and b are
|
||||
// vectors.
|
||||
//
|
||||
// At entry to the function, x contains the values of b, and the result is
|
||||
// stored in place into x.
|
||||
//
|
||||
// No test for singularity or near-singularity is included in this
|
||||
// routine. Such tests must be performed before calling this routine.
|
||||
func Tpsv(t blas.Transpose, a TriangularPacked, x Vector) {
|
||||
blas64.Dtpsv(a.Uplo, t, a.Diag, a.N, a.Data, x.Data, x.Inc)
|
||||
}
|
||||
|
||||
// Symv computes
|
||||
// y = alpha * A * x + beta * y,
|
||||
// where A is an n×n symmetric matrix, x and y are vectors, and alpha and
|
||||
// beta are scalars.
|
||||
func Symv(alpha float64, a Symmetric, x Vector, beta float64, y Vector) {
|
||||
blas64.Dsymv(a.Uplo, a.N, alpha, a.Data, a.Stride, x.Data, x.Inc, beta, y.Data, y.Inc)
|
||||
}
|
||||
|
||||
// Sbmv performs
|
||||
// y = alpha * A * x + beta * y,
|
||||
// where A is an n×n symmetric band matrix, x and y are vectors, and alpha
|
||||
// and beta are scalars.
|
||||
func Sbmv(alpha float64, a SymmetricBand, x Vector, beta float64, y Vector) {
|
||||
blas64.Dsbmv(a.Uplo, a.N, a.K, alpha, a.Data, a.Stride, x.Data, x.Inc, beta, y.Data, y.Inc)
|
||||
}
|
||||
|
||||
// Spmv performs
|
||||
// y = alpha * A * x + beta * y,
|
||||
// where A is an n×n symmetric matrix in packed format, x and y are vectors,
|
||||
// and alpha and beta are scalars.
|
||||
func Spmv(alpha float64, a SymmetricPacked, x Vector, beta float64, y Vector) {
|
||||
blas64.Dspmv(a.Uplo, a.N, alpha, a.Data, x.Data, x.Inc, beta, y.Data, y.Inc)
|
||||
}
|
||||
|
||||
// Ger performs a rank-1 update
|
||||
// A += alpha * x * y^T,
|
||||
// where A is an m×n dense matrix, x and y are vectors, and alpha is a scalar.
|
||||
func Ger(alpha float64, x, y Vector, a General) {
|
||||
blas64.Dger(a.Rows, a.Cols, alpha, x.Data, x.Inc, y.Data, y.Inc, a.Data, a.Stride)
|
||||
}
|
||||
|
||||
// Syr performs a rank-1 update
|
||||
// A += alpha * x * x^T,
|
||||
// where A is an n×n symmetric matrix, x is a vector, and alpha is a scalar.
|
||||
func Syr(alpha float64, x Vector, a Symmetric) {
|
||||
blas64.Dsyr(a.Uplo, a.N, alpha, x.Data, x.Inc, a.Data, a.Stride)
|
||||
}
|
||||
|
||||
// Spr performs the rank-1 update
|
||||
// A += alpha * x * x^T,
|
||||
// where A is an n×n symmetric matrix in packed format, x is a vector, and
|
||||
// alpha is a scalar.
|
||||
func Spr(alpha float64, x Vector, a SymmetricPacked) {
|
||||
blas64.Dspr(a.Uplo, a.N, alpha, x.Data, x.Inc, a.Data)
|
||||
}
|
||||
|
||||
// Syr2 performs a rank-2 update
|
||||
// A += alpha * x * y^T + alpha * y * x^T,
|
||||
// where A is a symmetric n×n matrix, x and y are vectors, and alpha is a scalar.
|
||||
func Syr2(alpha float64, x, y Vector, a Symmetric) {
|
||||
blas64.Dsyr2(a.Uplo, a.N, alpha, x.Data, x.Inc, y.Data, y.Inc, a.Data, a.Stride)
|
||||
}
|
||||
|
||||
// Spr2 performs a rank-2 update
|
||||
// A += alpha * x * y^T + alpha * y * x^T,
|
||||
// where A is an n×n symmetric matrix in packed format, x and y are vectors,
|
||||
// and alpha is a scalar.
|
||||
func Spr2(alpha float64, x, y Vector, a SymmetricPacked) {
|
||||
blas64.Dspr2(a.Uplo, a.N, alpha, x.Data, x.Inc, y.Data, y.Inc, a.Data)
|
||||
}
|
||||
|
||||
// Level 3
|
||||
|
||||
// Gemm computes
|
||||
// C = alpha * A * B + beta * C,
|
||||
// where A, B, and C are dense matrices, and alpha and beta are scalars.
|
||||
// tA and tB specify whether A or B are transposed.
|
||||
func Gemm(tA, tB blas.Transpose, alpha float64, a, b General, beta float64, c General) {
|
||||
var m, n, k int
|
||||
if tA == blas.NoTrans {
|
||||
m, k = a.Rows, a.Cols
|
||||
} else {
|
||||
m, k = a.Cols, a.Rows
|
||||
}
|
||||
if tB == blas.NoTrans {
|
||||
n = b.Cols
|
||||
} else {
|
||||
n = b.Rows
|
||||
}
|
||||
blas64.Dgemm(tA, tB, m, n, k, alpha, a.Data, a.Stride, b.Data, b.Stride, beta, c.Data, c.Stride)
|
||||
}
|
||||
|
||||
// Symm performs
|
||||
// C = alpha * A * B + beta * C, if s == blas.Left,
|
||||
// C = alpha * B * A + beta * C, if s == blas.Right,
|
||||
// where A is an n×n or m×m symmetric matrix, B and C are m×n matrices, and
|
||||
// alpha is a scalar.
|
||||
func Symm(s blas.Side, alpha float64, a Symmetric, b General, beta float64, c General) {
|
||||
var m, n int
|
||||
if s == blas.Left {
|
||||
m, n = a.N, b.Cols
|
||||
} else {
|
||||
m, n = b.Rows, a.N
|
||||
}
|
||||
blas64.Dsymm(s, a.Uplo, m, n, alpha, a.Data, a.Stride, b.Data, b.Stride, beta, c.Data, c.Stride)
|
||||
}
|
||||
|
||||
// Syrk performs a symmetric rank-k update
|
||||
// C = alpha * A * A^T + beta * C, if t == blas.NoTrans,
|
||||
// C = alpha * A^T * A + beta * C, if t == blas.Trans or blas.ConjTrans,
|
||||
// where C is an n×n symmetric matrix, A is an n×k matrix if t == blas.NoTrans and
|
||||
// a k×n matrix otherwise, and alpha and beta are scalars.
|
||||
func Syrk(t blas.Transpose, alpha float64, a General, beta float64, c Symmetric) {
|
||||
var n, k int
|
||||
if t == blas.NoTrans {
|
||||
n, k = a.Rows, a.Cols
|
||||
} else {
|
||||
n, k = a.Cols, a.Rows
|
||||
}
|
||||
blas64.Dsyrk(c.Uplo, t, n, k, alpha, a.Data, a.Stride, beta, c.Data, c.Stride)
|
||||
}
|
||||
|
||||
// Syr2k performs a symmetric rank-2k update
|
||||
// C = alpha * A * B^T + alpha * B * A^T + beta * C, if t == blas.NoTrans,
|
||||
// C = alpha * A^T * B + alpha * B^T * A + beta * C, if t == blas.Trans or blas.ConjTrans,
|
||||
// where C is an n×n symmetric matrix, A and B are n×k matrices if t == NoTrans
|
||||
// and k×n matrices otherwise, and alpha and beta are scalars.
|
||||
func Syr2k(t blas.Transpose, alpha float64, a, b General, beta float64, c Symmetric) {
|
||||
var n, k int
|
||||
if t == blas.NoTrans {
|
||||
n, k = a.Rows, a.Cols
|
||||
} else {
|
||||
n, k = a.Cols, a.Rows
|
||||
}
|
||||
blas64.Dsyr2k(c.Uplo, t, n, k, alpha, a.Data, a.Stride, b.Data, b.Stride, beta, c.Data, c.Stride)
|
||||
}
|
||||
|
||||
// Trmm performs
|
||||
// B = alpha * A * B, if tA == blas.NoTrans and s == blas.Left,
|
||||
// B = alpha * A^T * B, if tA == blas.Trans or blas.ConjTrans, and s == blas.Left,
|
||||
// B = alpha * B * A, if tA == blas.NoTrans and s == blas.Right,
|
||||
// B = alpha * B * A^T, if tA == blas.Trans or blas.ConjTrans, and s == blas.Right,
|
||||
// where A is an n×n or m×m triangular matrix, B is an m×n matrix, and alpha is
|
||||
// a scalar.
|
||||
func Trmm(s blas.Side, tA blas.Transpose, alpha float64, a Triangular, b General) {
|
||||
blas64.Dtrmm(s, a.Uplo, tA, a.Diag, b.Rows, b.Cols, alpha, a.Data, a.Stride, b.Data, b.Stride)
|
||||
}
|
||||
|
||||
// Trsm solves
|
||||
// A * X = alpha * B, if tA == blas.NoTrans and s == blas.Left,
|
||||
// A^T * X = alpha * B, if tA == blas.Trans or blas.ConjTrans, and s == blas.Left,
|
||||
// X * A = alpha * B, if tA == blas.NoTrans and s == blas.Right,
|
||||
// X * A^T = alpha * B, if tA == blas.Trans or blas.ConjTrans, and s == blas.Right,
|
||||
// where A is an n×n or m×m triangular matrix, X and B are m×n matrices, and
|
||||
// alpha is a scalar.
|
||||
//
|
||||
// At entry to the function, X contains the values of B, and the result is
|
||||
// stored in-place into X.
|
||||
//
|
||||
// No check is made that A is invertible.
|
||||
func Trsm(s blas.Side, tA blas.Transpose, alpha float64, a Triangular, b General) {
|
||||
blas64.Dtrsm(s, a.Uplo, tA, a.Diag, b.Rows, b.Cols, alpha, a.Data, a.Stride, b.Data, b.Stride)
|
||||
}
|
||||
277
vendor/gonum.org/v1/gonum/blas/blas64/conv.go
generated
vendored
Normal file
277
vendor/gonum.org/v1/gonum/blas/blas64/conv.go
generated
vendored
Normal file
@@ -0,0 +1,277 @@
|
||||
// Copyright ©2015 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package blas64
|
||||
|
||||
import "gonum.org/v1/gonum/blas"
|
||||
|
||||
// GeneralCols represents a matrix using the conventional column-major storage scheme.
|
||||
type GeneralCols General
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions as a and have adequate backing
|
||||
// data storage.
|
||||
func (t GeneralCols) From(a General) {
|
||||
if t.Rows != a.Rows || t.Cols != a.Cols {
|
||||
panic("blas64: mismatched dimension")
|
||||
}
|
||||
if len(t.Data) < (t.Cols-1)*t.Stride+t.Rows {
|
||||
panic("blas64: short data slice")
|
||||
}
|
||||
for i := 0; i < a.Rows; i++ {
|
||||
for j, v := range a.Data[i*a.Stride : i*a.Stride+a.Cols] {
|
||||
t.Data[i+j*t.Stride] = v
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions as a and have adequate backing
|
||||
// data storage.
|
||||
func (t General) From(a GeneralCols) {
|
||||
if t.Rows != a.Rows || t.Cols != a.Cols {
|
||||
panic("blas64: mismatched dimension")
|
||||
}
|
||||
if len(t.Data) < (t.Rows-1)*t.Stride+t.Cols {
|
||||
panic("blas64: short data slice")
|
||||
}
|
||||
for j := 0; j < a.Cols; j++ {
|
||||
for i, v := range a.Data[j*a.Stride : j*a.Stride+a.Rows] {
|
||||
t.Data[i*t.Stride+j] = v
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TriangularCols represents a matrix using the conventional column-major storage scheme.
|
||||
type TriangularCols Triangular
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions, uplo and diag as a and have
|
||||
// adequate backing data storage.
|
||||
func (t TriangularCols) From(a Triangular) {
|
||||
if t.N != a.N {
|
||||
panic("blas64: mismatched dimension")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("blas64: mismatched BLAS uplo")
|
||||
}
|
||||
if t.Diag != a.Diag {
|
||||
panic("blas64: mismatched BLAS diag")
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("blas64: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := i; j < a.N; j++ {
|
||||
t.Data[i+j*t.Stride] = a.Data[i*a.Stride+j]
|
||||
}
|
||||
}
|
||||
case blas.Lower:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := 0; j <= i; j++ {
|
||||
t.Data[i+j*t.Stride] = a.Data[i*a.Stride+j]
|
||||
}
|
||||
}
|
||||
case blas.All:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := 0; j < a.N; j++ {
|
||||
t.Data[i+j*t.Stride] = a.Data[i*a.Stride+j]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions, uplo and diag as a and have
|
||||
// adequate backing data storage.
|
||||
func (t Triangular) From(a TriangularCols) {
|
||||
if t.N != a.N {
|
||||
panic("blas64: mismatched dimension")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("blas64: mismatched BLAS uplo")
|
||||
}
|
||||
if t.Diag != a.Diag {
|
||||
panic("blas64: mismatched BLAS diag")
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("blas64: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := i; j < a.N; j++ {
|
||||
t.Data[i*t.Stride+j] = a.Data[i+j*a.Stride]
|
||||
}
|
||||
}
|
||||
case blas.Lower:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := 0; j <= i; j++ {
|
||||
t.Data[i*t.Stride+j] = a.Data[i+j*a.Stride]
|
||||
}
|
||||
}
|
||||
case blas.All:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := 0; j < a.N; j++ {
|
||||
t.Data[i*t.Stride+j] = a.Data[i+j*a.Stride]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// BandCols represents a matrix using the band column-major storage scheme.
|
||||
type BandCols Band
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions and bandwidth as a and have
|
||||
// adequate backing data storage.
|
||||
func (t BandCols) From(a Band) {
|
||||
if t.Rows != a.Rows || t.Cols != a.Cols {
|
||||
panic("blas64: mismatched dimension")
|
||||
}
|
||||
if t.KL != a.KL || t.KU != a.KU {
|
||||
panic("blas64: mismatched bandwidth")
|
||||
}
|
||||
if a.Stride < a.KL+a.KU+1 {
|
||||
panic("blas64: short stride for source")
|
||||
}
|
||||
if t.Stride < t.KL+t.KU+1 {
|
||||
panic("blas64: short stride for destination")
|
||||
}
|
||||
for i := 0; i < a.Rows; i++ {
|
||||
for j := max(0, i-a.KL); j < min(i+a.KU+1, a.Cols); j++ {
|
||||
t.Data[i+t.KU-j+j*t.Stride] = a.Data[j+a.KL-i+i*a.Stride]
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions and bandwidth as a and have
|
||||
// adequate backing data storage.
|
||||
func (t Band) From(a BandCols) {
|
||||
if t.Rows != a.Rows || t.Cols != a.Cols {
|
||||
panic("blas64: mismatched dimension")
|
||||
}
|
||||
if t.KL != a.KL || t.KU != a.KU {
|
||||
panic("blas64: mismatched bandwidth")
|
||||
}
|
||||
if a.Stride < a.KL+a.KU+1 {
|
||||
panic("blas64: short stride for source")
|
||||
}
|
||||
if t.Stride < t.KL+t.KU+1 {
|
||||
panic("blas64: short stride for destination")
|
||||
}
|
||||
for j := 0; j < a.Cols; j++ {
|
||||
for i := max(0, j-a.KU); i < min(j+a.KL+1, a.Rows); i++ {
|
||||
t.Data[j+a.KL-i+i*a.Stride] = a.Data[i+t.KU-j+j*t.Stride]
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TriangularBandCols represents a symmetric matrix using the band column-major storage scheme.
|
||||
type TriangularBandCols TriangularBand
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions, bandwidth and uplo as a and
|
||||
// have adequate backing data storage.
|
||||
func (t TriangularBandCols) From(a TriangularBand) {
|
||||
if t.N != a.N {
|
||||
panic("blas64: mismatched dimension")
|
||||
}
|
||||
if t.K != a.K {
|
||||
panic("blas64: mismatched bandwidth")
|
||||
}
|
||||
if a.Stride < a.K+1 {
|
||||
panic("blas64: short stride for source")
|
||||
}
|
||||
if t.Stride < t.K+1 {
|
||||
panic("blas64: short stride for destination")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("blas64: mismatched BLAS uplo")
|
||||
}
|
||||
if t.Diag != a.Diag {
|
||||
panic("blas64: mismatched BLAS diag")
|
||||
}
|
||||
dst := BandCols{
|
||||
Rows: t.N, Cols: t.N,
|
||||
Stride: t.Stride,
|
||||
Data: t.Data,
|
||||
}
|
||||
src := Band{
|
||||
Rows: a.N, Cols: a.N,
|
||||
Stride: a.Stride,
|
||||
Data: a.Data,
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("blas64: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
dst.KU = t.K
|
||||
src.KU = a.K
|
||||
case blas.Lower:
|
||||
dst.KL = t.K
|
||||
src.KL = a.K
|
||||
}
|
||||
dst.From(src)
|
||||
}
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions, bandwidth and uplo as a and
|
||||
// have adequate backing data storage.
|
||||
func (t TriangularBand) From(a TriangularBandCols) {
|
||||
if t.N != a.N {
|
||||
panic("blas64: mismatched dimension")
|
||||
}
|
||||
if t.K != a.K {
|
||||
panic("blas64: mismatched bandwidth")
|
||||
}
|
||||
if a.Stride < a.K+1 {
|
||||
panic("blas64: short stride for source")
|
||||
}
|
||||
if t.Stride < t.K+1 {
|
||||
panic("blas64: short stride for destination")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("blas64: mismatched BLAS uplo")
|
||||
}
|
||||
if t.Diag != a.Diag {
|
||||
panic("blas64: mismatched BLAS diag")
|
||||
}
|
||||
dst := Band{
|
||||
Rows: t.N, Cols: t.N,
|
||||
Stride: t.Stride,
|
||||
Data: t.Data,
|
||||
}
|
||||
src := BandCols{
|
||||
Rows: a.N, Cols: a.N,
|
||||
Stride: a.Stride,
|
||||
Data: a.Data,
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("blas64: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
dst.KU = t.K
|
||||
src.KU = a.K
|
||||
case blas.Lower:
|
||||
dst.KL = t.K
|
||||
src.KL = a.K
|
||||
}
|
||||
dst.From(src)
|
||||
}
|
||||
|
||||
func min(a, b int) int {
|
||||
if a < b {
|
||||
return a
|
||||
}
|
||||
return b
|
||||
}
|
||||
|
||||
func max(a, b int) int {
|
||||
if a > b {
|
||||
return a
|
||||
}
|
||||
return b
|
||||
}
|
||||
153
vendor/gonum.org/v1/gonum/blas/blas64/conv_symmetric.go
generated
vendored
Normal file
153
vendor/gonum.org/v1/gonum/blas/blas64/conv_symmetric.go
generated
vendored
Normal file
@@ -0,0 +1,153 @@
|
||||
// Copyright ©2015 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package blas64
|
||||
|
||||
import "gonum.org/v1/gonum/blas"
|
||||
|
||||
// SymmetricCols represents a matrix using the conventional column-major storage scheme.
|
||||
type SymmetricCols Symmetric
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions and uplo as a and have adequate
|
||||
// backing data storage.
|
||||
func (t SymmetricCols) From(a Symmetric) {
|
||||
if t.N != a.N {
|
||||
panic("blas64: mismatched dimension")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("blas64: mismatched BLAS uplo")
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("blas64: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := i; j < a.N; j++ {
|
||||
t.Data[i+j*t.Stride] = a.Data[i*a.Stride+j]
|
||||
}
|
||||
}
|
||||
case blas.Lower:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := 0; j <= i; j++ {
|
||||
t.Data[i+j*t.Stride] = a.Data[i*a.Stride+j]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions and uplo as a and have adequate
|
||||
// backing data storage.
|
||||
func (t Symmetric) From(a SymmetricCols) {
|
||||
if t.N != a.N {
|
||||
panic("blas64: mismatched dimension")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("blas64: mismatched BLAS uplo")
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("blas64: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := i; j < a.N; j++ {
|
||||
t.Data[i*t.Stride+j] = a.Data[i+j*a.Stride]
|
||||
}
|
||||
}
|
||||
case blas.Lower:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := 0; j <= i; j++ {
|
||||
t.Data[i*t.Stride+j] = a.Data[i+j*a.Stride]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// SymmetricBandCols represents a symmetric matrix using the band column-major storage scheme.
|
||||
type SymmetricBandCols SymmetricBand
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions, bandwidth and uplo as a and
|
||||
// have adequate backing data storage.
|
||||
func (t SymmetricBandCols) From(a SymmetricBand) {
|
||||
if t.N != a.N {
|
||||
panic("blas64: mismatched dimension")
|
||||
}
|
||||
if t.K != a.K {
|
||||
panic("blas64: mismatched bandwidth")
|
||||
}
|
||||
if a.Stride < a.K+1 {
|
||||
panic("blas64: short stride for source")
|
||||
}
|
||||
if t.Stride < t.K+1 {
|
||||
panic("blas64: short stride for destination")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("blas64: mismatched BLAS uplo")
|
||||
}
|
||||
dst := BandCols{
|
||||
Rows: t.N, Cols: t.N,
|
||||
Stride: t.Stride,
|
||||
Data: t.Data,
|
||||
}
|
||||
src := Band{
|
||||
Rows: a.N, Cols: a.N,
|
||||
Stride: a.Stride,
|
||||
Data: a.Data,
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("blas64: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
dst.KU = t.K
|
||||
src.KU = a.K
|
||||
case blas.Lower:
|
||||
dst.KL = t.K
|
||||
src.KL = a.K
|
||||
}
|
||||
dst.From(src)
|
||||
}
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions, bandwidth and uplo as a and
|
||||
// have adequate backing data storage.
|
||||
func (t SymmetricBand) From(a SymmetricBandCols) {
|
||||
if t.N != a.N {
|
||||
panic("blas64: mismatched dimension")
|
||||
}
|
||||
if t.K != a.K {
|
||||
panic("blas64: mismatched bandwidth")
|
||||
}
|
||||
if a.Stride < a.K+1 {
|
||||
panic("blas64: short stride for source")
|
||||
}
|
||||
if t.Stride < t.K+1 {
|
||||
panic("blas64: short stride for destination")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("blas64: mismatched BLAS uplo")
|
||||
}
|
||||
dst := Band{
|
||||
Rows: t.N, Cols: t.N,
|
||||
Stride: t.Stride,
|
||||
Data: t.Data,
|
||||
}
|
||||
src := BandCols{
|
||||
Rows: a.N, Cols: a.N,
|
||||
Stride: a.Stride,
|
||||
Data: a.Data,
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("blas64: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
dst.KU = t.K
|
||||
src.KU = a.K
|
||||
case blas.Lower:
|
||||
dst.KL = t.K
|
||||
src.KL = a.K
|
||||
}
|
||||
dst.From(src)
|
||||
}
|
||||
6
vendor/gonum.org/v1/gonum/blas/blas64/doc.go
generated
vendored
Normal file
6
vendor/gonum.org/v1/gonum/blas/blas64/doc.go
generated
vendored
Normal file
@@ -0,0 +1,6 @@
|
||||
// Copyright ©2017 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
// Package blas64 provides a simple interface to the float64 BLAS API.
|
||||
package blas64 // import "gonum.org/v1/gonum/blas/blas64"
|
||||
508
vendor/gonum.org/v1/gonum/blas/cblas128/cblas128.go
generated
vendored
Normal file
508
vendor/gonum.org/v1/gonum/blas/cblas128/cblas128.go
generated
vendored
Normal file
@@ -0,0 +1,508 @@
|
||||
// Copyright ©2015 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package cblas128
|
||||
|
||||
import (
|
||||
"gonum.org/v1/gonum/blas"
|
||||
"gonum.org/v1/gonum/blas/gonum"
|
||||
)
|
||||
|
||||
var cblas128 blas.Complex128 = gonum.Implementation{}
|
||||
|
||||
// Use sets the BLAS complex128 implementation to be used by subsequent BLAS calls.
|
||||
// The default implementation is
|
||||
// gonum.org/v1/gonum/blas/gonum.Implementation.
|
||||
func Use(b blas.Complex128) {
|
||||
cblas128 = b
|
||||
}
|
||||
|
||||
// Implementation returns the current BLAS complex128 implementation.
|
||||
//
|
||||
// Implementation allows direct calls to the current the BLAS complex128 implementation
|
||||
// giving finer control of parameters.
|
||||
func Implementation() blas.Complex128 {
|
||||
return cblas128
|
||||
}
|
||||
|
||||
// Vector represents a vector with an associated element increment.
|
||||
type Vector struct {
|
||||
Inc int
|
||||
Data []complex128
|
||||
}
|
||||
|
||||
// General represents a matrix using the conventional storage scheme.
|
||||
type General struct {
|
||||
Rows, Cols int
|
||||
Stride int
|
||||
Data []complex128
|
||||
}
|
||||
|
||||
// Band represents a band matrix using the band storage scheme.
|
||||
type Band struct {
|
||||
Rows, Cols int
|
||||
KL, KU int
|
||||
Stride int
|
||||
Data []complex128
|
||||
}
|
||||
|
||||
// Triangular represents a triangular matrix using the conventional storage scheme.
|
||||
type Triangular struct {
|
||||
N int
|
||||
Stride int
|
||||
Data []complex128
|
||||
Uplo blas.Uplo
|
||||
Diag blas.Diag
|
||||
}
|
||||
|
||||
// TriangularBand represents a triangular matrix using the band storage scheme.
|
||||
type TriangularBand struct {
|
||||
N, K int
|
||||
Stride int
|
||||
Data []complex128
|
||||
Uplo blas.Uplo
|
||||
Diag blas.Diag
|
||||
}
|
||||
|
||||
// TriangularPacked represents a triangular matrix using the packed storage scheme.
|
||||
type TriangularPacked struct {
|
||||
N int
|
||||
Data []complex128
|
||||
Uplo blas.Uplo
|
||||
Diag blas.Diag
|
||||
}
|
||||
|
||||
// Symmetric represents a symmetric matrix using the conventional storage scheme.
|
||||
type Symmetric struct {
|
||||
N int
|
||||
Stride int
|
||||
Data []complex128
|
||||
Uplo blas.Uplo
|
||||
}
|
||||
|
||||
// SymmetricBand represents a symmetric matrix using the band storage scheme.
|
||||
type SymmetricBand struct {
|
||||
N, K int
|
||||
Stride int
|
||||
Data []complex128
|
||||
Uplo blas.Uplo
|
||||
}
|
||||
|
||||
// SymmetricPacked represents a symmetric matrix using the packed storage scheme.
|
||||
type SymmetricPacked struct {
|
||||
N int
|
||||
Data []complex128
|
||||
Uplo blas.Uplo
|
||||
}
|
||||
|
||||
// Hermitian represents an Hermitian matrix using the conventional storage scheme.
|
||||
type Hermitian Symmetric
|
||||
|
||||
// HermitianBand represents an Hermitian matrix using the band storage scheme.
|
||||
type HermitianBand SymmetricBand
|
||||
|
||||
// HermitianPacked represents an Hermitian matrix using the packed storage scheme.
|
||||
type HermitianPacked SymmetricPacked
|
||||
|
||||
// Level 1
|
||||
|
||||
const negInc = "cblas128: negative vector increment"
|
||||
|
||||
// Dotu computes the dot product of the two vectors without
|
||||
// complex conjugation:
|
||||
// x^T * y.
|
||||
func Dotu(n int, x, y Vector) complex128 {
|
||||
return cblas128.Zdotu(n, x.Data, x.Inc, y.Data, y.Inc)
|
||||
}
|
||||
|
||||
// Dotc computes the dot product of the two vectors with
|
||||
// complex conjugation:
|
||||
// x^H * y.
|
||||
func Dotc(n int, x, y Vector) complex128 {
|
||||
return cblas128.Zdotc(n, x.Data, x.Inc, y.Data, y.Inc)
|
||||
}
|
||||
|
||||
// Nrm2 computes the Euclidean norm of the vector x:
|
||||
// sqrt(\sum_i x[i] * x[i]).
|
||||
//
|
||||
// Nrm2 will panic if the vector increment is negative.
|
||||
func Nrm2(n int, x Vector) float64 {
|
||||
if x.Inc < 0 {
|
||||
panic(negInc)
|
||||
}
|
||||
return cblas128.Dznrm2(n, x.Data, x.Inc)
|
||||
}
|
||||
|
||||
// Asum computes the sum of magnitudes of the real and imaginary parts of
|
||||
// elements of the vector x:
|
||||
// \sum_i (|Re x[i]| + |Im x[i]|).
|
||||
//
|
||||
// Asum will panic if the vector increment is negative.
|
||||
func Asum(n int, x Vector) float64 {
|
||||
if x.Inc < 0 {
|
||||
panic(negInc)
|
||||
}
|
||||
return cblas128.Dzasum(n, x.Data, x.Inc)
|
||||
}
|
||||
|
||||
// Iamax returns the index of an element of x with the largest sum of
|
||||
// magnitudes of the real and imaginary parts (|Re x[i]|+|Im x[i]|).
|
||||
// If there are multiple such indices, the earliest is returned.
|
||||
//
|
||||
// Iamax returns -1 if n == 0.
|
||||
//
|
||||
// Iamax will panic if the vector increment is negative.
|
||||
func Iamax(n int, x Vector) int {
|
||||
if x.Inc < 0 {
|
||||
panic(negInc)
|
||||
}
|
||||
return cblas128.Izamax(n, x.Data, x.Inc)
|
||||
}
|
||||
|
||||
// Swap exchanges the elements of two vectors:
|
||||
// x[i], y[i] = y[i], x[i] for all i.
|
||||
func Swap(n int, x, y Vector) {
|
||||
cblas128.Zswap(n, x.Data, x.Inc, y.Data, y.Inc)
|
||||
}
|
||||
|
||||
// Copy copies the elements of x into the elements of y:
|
||||
// y[i] = x[i] for all i.
|
||||
func Copy(n int, x, y Vector) {
|
||||
cblas128.Zcopy(n, x.Data, x.Inc, y.Data, y.Inc)
|
||||
}
|
||||
|
||||
// Axpy computes
|
||||
// y = alpha * x + y,
|
||||
// where x and y are vectors, and alpha is a scalar.
|
||||
func Axpy(n int, alpha complex128, x, y Vector) {
|
||||
cblas128.Zaxpy(n, alpha, x.Data, x.Inc, y.Data, y.Inc)
|
||||
}
|
||||
|
||||
// Scal computes
|
||||
// x = alpha * x,
|
||||
// where x is a vector, and alpha is a scalar.
|
||||
//
|
||||
// Scal will panic if the vector increment is negative.
|
||||
func Scal(n int, alpha complex128, x Vector) {
|
||||
if x.Inc < 0 {
|
||||
panic(negInc)
|
||||
}
|
||||
cblas128.Zscal(n, alpha, x.Data, x.Inc)
|
||||
}
|
||||
|
||||
// Dscal computes
|
||||
// x = alpha * x,
|
||||
// where x is a vector, and alpha is a real scalar.
|
||||
//
|
||||
// Dscal will panic if the vector increment is negative.
|
||||
func Dscal(n int, alpha float64, x Vector) {
|
||||
if x.Inc < 0 {
|
||||
panic(negInc)
|
||||
}
|
||||
cblas128.Zdscal(n, alpha, x.Data, x.Inc)
|
||||
}
|
||||
|
||||
// Level 2
|
||||
|
||||
// Gemv computes
|
||||
// y = alpha * A * x + beta * y, if t == blas.NoTrans,
|
||||
// y = alpha * A^T * x + beta * y, if t == blas.Trans,
|
||||
// y = alpha * A^H * x + beta * y, if t == blas.ConjTrans,
|
||||
// where A is an m×n dense matrix, x and y are vectors, and alpha and beta are
|
||||
// scalars.
|
||||
func Gemv(t blas.Transpose, alpha complex128, a General, x Vector, beta complex128, y Vector) {
|
||||
cblas128.Zgemv(t, a.Rows, a.Cols, alpha, a.Data, a.Stride, x.Data, x.Inc, beta, y.Data, y.Inc)
|
||||
}
|
||||
|
||||
// Gbmv computes
|
||||
// y = alpha * A * x + beta * y, if t == blas.NoTrans,
|
||||
// y = alpha * A^T * x + beta * y, if t == blas.Trans,
|
||||
// y = alpha * A^H * x + beta * y, if t == blas.ConjTrans,
|
||||
// where A is an m×n band matrix, x and y are vectors, and alpha and beta are
|
||||
// scalars.
|
||||
func Gbmv(t blas.Transpose, alpha complex128, a Band, x Vector, beta complex128, y Vector) {
|
||||
cblas128.Zgbmv(t, a.Rows, a.Cols, a.KL, a.KU, alpha, a.Data, a.Stride, x.Data, x.Inc, beta, y.Data, y.Inc)
|
||||
}
|
||||
|
||||
// Trmv computes
|
||||
// x = A * x, if t == blas.NoTrans,
|
||||
// x = A^T * x, if t == blas.Trans,
|
||||
// x = A^H * x, if t == blas.ConjTrans,
|
||||
// where A is an n×n triangular matrix, and x is a vector.
|
||||
func Trmv(t blas.Transpose, a Triangular, x Vector) {
|
||||
cblas128.Ztrmv(a.Uplo, t, a.Diag, a.N, a.Data, a.Stride, x.Data, x.Inc)
|
||||
}
|
||||
|
||||
// Tbmv computes
|
||||
// x = A * x, if t == blas.NoTrans,
|
||||
// x = A^T * x, if t == blas.Trans,
|
||||
// x = A^H * x, if t == blas.ConjTrans,
|
||||
// where A is an n×n triangular band matrix, and x is a vector.
|
||||
func Tbmv(t blas.Transpose, a TriangularBand, x Vector) {
|
||||
cblas128.Ztbmv(a.Uplo, t, a.Diag, a.N, a.K, a.Data, a.Stride, x.Data, x.Inc)
|
||||
}
|
||||
|
||||
// Tpmv computes
|
||||
// x = A * x, if t == blas.NoTrans,
|
||||
// x = A^T * x, if t == blas.Trans,
|
||||
// x = A^H * x, if t == blas.ConjTrans,
|
||||
// where A is an n×n triangular matrix in packed format, and x is a vector.
|
||||
func Tpmv(t blas.Transpose, a TriangularPacked, x Vector) {
|
||||
cblas128.Ztpmv(a.Uplo, t, a.Diag, a.N, a.Data, x.Data, x.Inc)
|
||||
}
|
||||
|
||||
// Trsv solves
|
||||
// A * x = b, if t == blas.NoTrans,
|
||||
// A^T * x = b, if t == blas.Trans,
|
||||
// A^H * x = b, if t == blas.ConjTrans,
|
||||
// where A is an n×n triangular matrix and x is a vector.
|
||||
//
|
||||
// At entry to the function, x contains the values of b, and the result is
|
||||
// stored in-place into x.
|
||||
//
|
||||
// No test for singularity or near-singularity is included in this
|
||||
// routine. Such tests must be performed before calling this routine.
|
||||
func Trsv(t blas.Transpose, a Triangular, x Vector) {
|
||||
cblas128.Ztrsv(a.Uplo, t, a.Diag, a.N, a.Data, a.Stride, x.Data, x.Inc)
|
||||
}
|
||||
|
||||
// Tbsv solves
|
||||
// A * x = b, if t == blas.NoTrans,
|
||||
// A^T * x = b, if t == blas.Trans,
|
||||
// A^H * x = b, if t == blas.ConjTrans,
|
||||
// where A is an n×n triangular band matrix, and x is a vector.
|
||||
//
|
||||
// At entry to the function, x contains the values of b, and the result is
|
||||
// stored in-place into x.
|
||||
//
|
||||
// No test for singularity or near-singularity is included in this
|
||||
// routine. Such tests must be performed before calling this routine.
|
||||
func Tbsv(t blas.Transpose, a TriangularBand, x Vector) {
|
||||
cblas128.Ztbsv(a.Uplo, t, a.Diag, a.N, a.K, a.Data, a.Stride, x.Data, x.Inc)
|
||||
}
|
||||
|
||||
// Tpsv solves
|
||||
// A * x = b, if t == blas.NoTrans,
|
||||
// A^T * x = b, if t == blas.Trans,
|
||||
// A^H * x = b, if t == blas.ConjTrans,
|
||||
// where A is an n×n triangular matrix in packed format and x is a vector.
|
||||
//
|
||||
// At entry to the function, x contains the values of b, and the result is
|
||||
// stored in-place into x.
|
||||
//
|
||||
// No test for singularity or near-singularity is included in this
|
||||
// routine. Such tests must be performed before calling this routine.
|
||||
func Tpsv(t blas.Transpose, a TriangularPacked, x Vector) {
|
||||
cblas128.Ztpsv(a.Uplo, t, a.Diag, a.N, a.Data, x.Data, x.Inc)
|
||||
}
|
||||
|
||||
// Hemv computes
|
||||
// y = alpha * A * x + beta * y,
|
||||
// where A is an n×n Hermitian matrix, x and y are vectors, and alpha and
|
||||
// beta are scalars.
|
||||
func Hemv(alpha complex128, a Hermitian, x Vector, beta complex128, y Vector) {
|
||||
cblas128.Zhemv(a.Uplo, a.N, alpha, a.Data, a.Stride, x.Data, x.Inc, beta, y.Data, y.Inc)
|
||||
}
|
||||
|
||||
// Hbmv performs
|
||||
// y = alpha * A * x + beta * y,
|
||||
// where A is an n×n Hermitian band matrix, x and y are vectors, and alpha
|
||||
// and beta are scalars.
|
||||
func Hbmv(alpha complex128, a HermitianBand, x Vector, beta complex128, y Vector) {
|
||||
cblas128.Zhbmv(a.Uplo, a.N, a.K, alpha, a.Data, a.Stride, x.Data, x.Inc, beta, y.Data, y.Inc)
|
||||
}
|
||||
|
||||
// Hpmv performs
|
||||
// y = alpha * A * x + beta * y,
|
||||
// where A is an n×n Hermitian matrix in packed format, x and y are vectors,
|
||||
// and alpha and beta are scalars.
|
||||
func Hpmv(alpha complex128, a HermitianPacked, x Vector, beta complex128, y Vector) {
|
||||
cblas128.Zhpmv(a.Uplo, a.N, alpha, a.Data, x.Data, x.Inc, beta, y.Data, y.Inc)
|
||||
}
|
||||
|
||||
// Geru performs a rank-1 update
|
||||
// A += alpha * x * y^T,
|
||||
// where A is an m×n dense matrix, x and y are vectors, and alpha is a scalar.
|
||||
func Geru(alpha complex128, x, y Vector, a General) {
|
||||
cblas128.Zgeru(a.Rows, a.Cols, alpha, x.Data, x.Inc, y.Data, y.Inc, a.Data, a.Stride)
|
||||
}
|
||||
|
||||
// Gerc performs a rank-1 update
|
||||
// A += alpha * x * y^H,
|
||||
// where A is an m×n dense matrix, x and y are vectors, and alpha is a scalar.
|
||||
func Gerc(alpha complex128, x, y Vector, a General) {
|
||||
cblas128.Zgerc(a.Rows, a.Cols, alpha, x.Data, x.Inc, y.Data, y.Inc, a.Data, a.Stride)
|
||||
}
|
||||
|
||||
// Her performs a rank-1 update
|
||||
// A += alpha * x * y^T,
|
||||
// where A is an m×n Hermitian matrix, x and y are vectors, and alpha is a scalar.
|
||||
func Her(alpha float64, x Vector, a Hermitian) {
|
||||
cblas128.Zher(a.Uplo, a.N, alpha, x.Data, x.Inc, a.Data, a.Stride)
|
||||
}
|
||||
|
||||
// Hpr performs a rank-1 update
|
||||
// A += alpha * x * x^H,
|
||||
// where A is an n×n Hermitian matrix in packed format, x is a vector, and
|
||||
// alpha is a scalar.
|
||||
func Hpr(alpha float64, x Vector, a HermitianPacked) {
|
||||
cblas128.Zhpr(a.Uplo, a.N, alpha, x.Data, x.Inc, a.Data)
|
||||
}
|
||||
|
||||
// Her2 performs a rank-2 update
|
||||
// A += alpha * x * y^H + conj(alpha) * y * x^H,
|
||||
// where A is an n×n Hermitian matrix, x and y are vectors, and alpha is a scalar.
|
||||
func Her2(alpha complex128, x, y Vector, a Hermitian) {
|
||||
cblas128.Zher2(a.Uplo, a.N, alpha, x.Data, x.Inc, y.Data, y.Inc, a.Data, a.Stride)
|
||||
}
|
||||
|
||||
// Hpr2 performs a rank-2 update
|
||||
// A += alpha * x * y^H + conj(alpha) * y * x^H,
|
||||
// where A is an n×n Hermitian matrix in packed format, x and y are vectors,
|
||||
// and alpha is a scalar.
|
||||
func Hpr2(alpha complex128, x, y Vector, a HermitianPacked) {
|
||||
cblas128.Zhpr2(a.Uplo, a.N, alpha, x.Data, x.Inc, y.Data, y.Inc, a.Data)
|
||||
}
|
||||
|
||||
// Level 3
|
||||
|
||||
// Gemm computes
|
||||
// C = alpha * A * B + beta * C,
|
||||
// where A, B, and C are dense matrices, and alpha and beta are scalars.
|
||||
// tA and tB specify whether A or B are transposed or conjugated.
|
||||
func Gemm(tA, tB blas.Transpose, alpha complex128, a, b General, beta complex128, c General) {
|
||||
var m, n, k int
|
||||
if tA == blas.NoTrans {
|
||||
m, k = a.Rows, a.Cols
|
||||
} else {
|
||||
m, k = a.Cols, a.Rows
|
||||
}
|
||||
if tB == blas.NoTrans {
|
||||
n = b.Cols
|
||||
} else {
|
||||
n = b.Rows
|
||||
}
|
||||
cblas128.Zgemm(tA, tB, m, n, k, alpha, a.Data, a.Stride, b.Data, b.Stride, beta, c.Data, c.Stride)
|
||||
}
|
||||
|
||||
// Symm performs
|
||||
// C = alpha * A * B + beta * C, if s == blas.Left,
|
||||
// C = alpha * B * A + beta * C, if s == blas.Right,
|
||||
// where A is an n×n or m×m symmetric matrix, B and C are m×n matrices, and
|
||||
// alpha and beta are scalars.
|
||||
func Symm(s blas.Side, alpha complex128, a Symmetric, b General, beta complex128, c General) {
|
||||
var m, n int
|
||||
if s == blas.Left {
|
||||
m, n = a.N, b.Cols
|
||||
} else {
|
||||
m, n = b.Rows, a.N
|
||||
}
|
||||
cblas128.Zsymm(s, a.Uplo, m, n, alpha, a.Data, a.Stride, b.Data, b.Stride, beta, c.Data, c.Stride)
|
||||
}
|
||||
|
||||
// Syrk performs a symmetric rank-k update
|
||||
// C = alpha * A * A^T + beta * C, if t == blas.NoTrans,
|
||||
// C = alpha * A^T * A + beta * C, if t == blas.Trans,
|
||||
// where C is an n×n symmetric matrix, A is an n×k matrix if t == blas.NoTrans
|
||||
// and a k×n matrix otherwise, and alpha and beta are scalars.
|
||||
func Syrk(t blas.Transpose, alpha complex128, a General, beta complex128, c Symmetric) {
|
||||
var n, k int
|
||||
if t == blas.NoTrans {
|
||||
n, k = a.Rows, a.Cols
|
||||
} else {
|
||||
n, k = a.Cols, a.Rows
|
||||
}
|
||||
cblas128.Zsyrk(c.Uplo, t, n, k, alpha, a.Data, a.Stride, beta, c.Data, c.Stride)
|
||||
}
|
||||
|
||||
// Syr2k performs a symmetric rank-2k update
|
||||
// C = alpha * A * B^T + alpha * B * A^T + beta * C, if t == blas.NoTrans,
|
||||
// C = alpha * A^T * B + alpha * B^T * A + beta * C, if t == blas.Trans,
|
||||
// where C is an n×n symmetric matrix, A and B are n×k matrices if
|
||||
// t == blas.NoTrans and k×n otherwise, and alpha and beta are scalars.
|
||||
func Syr2k(t blas.Transpose, alpha complex128, a, b General, beta complex128, c Symmetric) {
|
||||
var n, k int
|
||||
if t == blas.NoTrans {
|
||||
n, k = a.Rows, a.Cols
|
||||
} else {
|
||||
n, k = a.Cols, a.Rows
|
||||
}
|
||||
cblas128.Zsyr2k(c.Uplo, t, n, k, alpha, a.Data, a.Stride, b.Data, b.Stride, beta, c.Data, c.Stride)
|
||||
}
|
||||
|
||||
// Trmm performs
|
||||
// B = alpha * A * B, if tA == blas.NoTrans and s == blas.Left,
|
||||
// B = alpha * A^T * B, if tA == blas.Trans and s == blas.Left,
|
||||
// B = alpha * A^H * B, if tA == blas.ConjTrans and s == blas.Left,
|
||||
// B = alpha * B * A, if tA == blas.NoTrans and s == blas.Right,
|
||||
// B = alpha * B * A^T, if tA == blas.Trans and s == blas.Right,
|
||||
// B = alpha * B * A^H, if tA == blas.ConjTrans and s == blas.Right,
|
||||
// where A is an n×n or m×m triangular matrix, B is an m×n matrix, and alpha is
|
||||
// a scalar.
|
||||
func Trmm(s blas.Side, tA blas.Transpose, alpha complex128, a Triangular, b General) {
|
||||
cblas128.Ztrmm(s, a.Uplo, tA, a.Diag, b.Rows, b.Cols, alpha, a.Data, a.Stride, b.Data, b.Stride)
|
||||
}
|
||||
|
||||
// Trsm solves
|
||||
// A * X = alpha * B, if tA == blas.NoTrans and s == blas.Left,
|
||||
// A^T * X = alpha * B, if tA == blas.Trans and s == blas.Left,
|
||||
// A^H * X = alpha * B, if tA == blas.ConjTrans and s == blas.Left,
|
||||
// X * A = alpha * B, if tA == blas.NoTrans and s == blas.Right,
|
||||
// X * A^T = alpha * B, if tA == blas.Trans and s == blas.Right,
|
||||
// X * A^H = alpha * B, if tA == blas.ConjTrans and s == blas.Right,
|
||||
// where A is an n×n or m×m triangular matrix, X and B are m×n matrices, and
|
||||
// alpha is a scalar.
|
||||
//
|
||||
// At entry to the function, b contains the values of B, and the result is
|
||||
// stored in-place into b.
|
||||
//
|
||||
// No check is made that A is invertible.
|
||||
func Trsm(s blas.Side, tA blas.Transpose, alpha complex128, a Triangular, b General) {
|
||||
cblas128.Ztrsm(s, a.Uplo, tA, a.Diag, b.Rows, b.Cols, alpha, a.Data, a.Stride, b.Data, b.Stride)
|
||||
}
|
||||
|
||||
// Hemm performs
|
||||
// C = alpha * A * B + beta * C, if s == blas.Left,
|
||||
// C = alpha * B * A + beta * C, if s == blas.Right,
|
||||
// where A is an n×n or m×m Hermitian matrix, B and C are m×n matrices, and
|
||||
// alpha and beta are scalars.
|
||||
func Hemm(s blas.Side, alpha complex128, a Hermitian, b General, beta complex128, c General) {
|
||||
var m, n int
|
||||
if s == blas.Left {
|
||||
m, n = a.N, b.Cols
|
||||
} else {
|
||||
m, n = b.Rows, a.N
|
||||
}
|
||||
cblas128.Zhemm(s, a.Uplo, m, n, alpha, a.Data, a.Stride, b.Data, b.Stride, beta, c.Data, c.Stride)
|
||||
}
|
||||
|
||||
// Herk performs the Hermitian rank-k update
|
||||
// C = alpha * A * A^H + beta*C, if t == blas.NoTrans,
|
||||
// C = alpha * A^H * A + beta*C, if t == blas.ConjTrans,
|
||||
// where C is an n×n Hermitian matrix, A is an n×k matrix if t == blas.NoTrans
|
||||
// and a k×n matrix otherwise, and alpha and beta are scalars.
|
||||
func Herk(t blas.Transpose, alpha float64, a General, beta float64, c Hermitian) {
|
||||
var n, k int
|
||||
if t == blas.NoTrans {
|
||||
n, k = a.Rows, a.Cols
|
||||
} else {
|
||||
n, k = a.Cols, a.Rows
|
||||
}
|
||||
cblas128.Zherk(c.Uplo, t, n, k, alpha, a.Data, a.Stride, beta, c.Data, c.Stride)
|
||||
}
|
||||
|
||||
// Her2k performs the Hermitian rank-2k update
|
||||
// C = alpha * A * B^H + conj(alpha) * B * A^H + beta * C, if t == blas.NoTrans,
|
||||
// C = alpha * A^H * B + conj(alpha) * B^H * A + beta * C, if t == blas.ConjTrans,
|
||||
// where C is an n×n Hermitian matrix, A and B are n×k matrices if t == NoTrans
|
||||
// and k×n matrices otherwise, and alpha and beta are scalars.
|
||||
func Her2k(t blas.Transpose, alpha complex128, a, b General, beta float64, c Hermitian) {
|
||||
var n, k int
|
||||
if t == blas.NoTrans {
|
||||
n, k = a.Rows, a.Cols
|
||||
} else {
|
||||
n, k = a.Cols, a.Rows
|
||||
}
|
||||
cblas128.Zher2k(c.Uplo, t, n, k, alpha, a.Data, a.Stride, b.Data, b.Stride, beta, c.Data, c.Stride)
|
||||
}
|
||||
279
vendor/gonum.org/v1/gonum/blas/cblas128/conv.go
generated
vendored
Normal file
279
vendor/gonum.org/v1/gonum/blas/cblas128/conv.go
generated
vendored
Normal file
@@ -0,0 +1,279 @@
|
||||
// Code generated by "go generate gonum.org/v1/gonum/blas”; DO NOT EDIT.
|
||||
|
||||
// Copyright ©2015 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package cblas128
|
||||
|
||||
import "gonum.org/v1/gonum/blas"
|
||||
|
||||
// GeneralCols represents a matrix using the conventional column-major storage scheme.
|
||||
type GeneralCols General
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions as a and have adequate backing
|
||||
// data storage.
|
||||
func (t GeneralCols) From(a General) {
|
||||
if t.Rows != a.Rows || t.Cols != a.Cols {
|
||||
panic("cblas128: mismatched dimension")
|
||||
}
|
||||
if len(t.Data) < (t.Cols-1)*t.Stride+t.Rows {
|
||||
panic("cblas128: short data slice")
|
||||
}
|
||||
for i := 0; i < a.Rows; i++ {
|
||||
for j, v := range a.Data[i*a.Stride : i*a.Stride+a.Cols] {
|
||||
t.Data[i+j*t.Stride] = v
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions as a and have adequate backing
|
||||
// data storage.
|
||||
func (t General) From(a GeneralCols) {
|
||||
if t.Rows != a.Rows || t.Cols != a.Cols {
|
||||
panic("cblas128: mismatched dimension")
|
||||
}
|
||||
if len(t.Data) < (t.Rows-1)*t.Stride+t.Cols {
|
||||
panic("cblas128: short data slice")
|
||||
}
|
||||
for j := 0; j < a.Cols; j++ {
|
||||
for i, v := range a.Data[j*a.Stride : j*a.Stride+a.Rows] {
|
||||
t.Data[i*t.Stride+j] = v
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TriangularCols represents a matrix using the conventional column-major storage scheme.
|
||||
type TriangularCols Triangular
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions, uplo and diag as a and have
|
||||
// adequate backing data storage.
|
||||
func (t TriangularCols) From(a Triangular) {
|
||||
if t.N != a.N {
|
||||
panic("cblas128: mismatched dimension")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("cblas128: mismatched BLAS uplo")
|
||||
}
|
||||
if t.Diag != a.Diag {
|
||||
panic("cblas128: mismatched BLAS diag")
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("cblas128: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := i; j < a.N; j++ {
|
||||
t.Data[i+j*t.Stride] = a.Data[i*a.Stride+j]
|
||||
}
|
||||
}
|
||||
case blas.Lower:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := 0; j <= i; j++ {
|
||||
t.Data[i+j*t.Stride] = a.Data[i*a.Stride+j]
|
||||
}
|
||||
}
|
||||
case blas.All:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := 0; j < a.N; j++ {
|
||||
t.Data[i+j*t.Stride] = a.Data[i*a.Stride+j]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions, uplo and diag as a and have
|
||||
// adequate backing data storage.
|
||||
func (t Triangular) From(a TriangularCols) {
|
||||
if t.N != a.N {
|
||||
panic("cblas128: mismatched dimension")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("cblas128: mismatched BLAS uplo")
|
||||
}
|
||||
if t.Diag != a.Diag {
|
||||
panic("cblas128: mismatched BLAS diag")
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("cblas128: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := i; j < a.N; j++ {
|
||||
t.Data[i*t.Stride+j] = a.Data[i+j*a.Stride]
|
||||
}
|
||||
}
|
||||
case blas.Lower:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := 0; j <= i; j++ {
|
||||
t.Data[i*t.Stride+j] = a.Data[i+j*a.Stride]
|
||||
}
|
||||
}
|
||||
case blas.All:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := 0; j < a.N; j++ {
|
||||
t.Data[i*t.Stride+j] = a.Data[i+j*a.Stride]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// BandCols represents a matrix using the band column-major storage scheme.
|
||||
type BandCols Band
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions and bandwidth as a and have
|
||||
// adequate backing data storage.
|
||||
func (t BandCols) From(a Band) {
|
||||
if t.Rows != a.Rows || t.Cols != a.Cols {
|
||||
panic("cblas128: mismatched dimension")
|
||||
}
|
||||
if t.KL != a.KL || t.KU != a.KU {
|
||||
panic("cblas128: mismatched bandwidth")
|
||||
}
|
||||
if a.Stride < a.KL+a.KU+1 {
|
||||
panic("cblas128: short stride for source")
|
||||
}
|
||||
if t.Stride < t.KL+t.KU+1 {
|
||||
panic("cblas128: short stride for destination")
|
||||
}
|
||||
for i := 0; i < a.Rows; i++ {
|
||||
for j := max(0, i-a.KL); j < min(i+a.KU+1, a.Cols); j++ {
|
||||
t.Data[i+t.KU-j+j*t.Stride] = a.Data[j+a.KL-i+i*a.Stride]
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions and bandwidth as a and have
|
||||
// adequate backing data storage.
|
||||
func (t Band) From(a BandCols) {
|
||||
if t.Rows != a.Rows || t.Cols != a.Cols {
|
||||
panic("cblas128: mismatched dimension")
|
||||
}
|
||||
if t.KL != a.KL || t.KU != a.KU {
|
||||
panic("cblas128: mismatched bandwidth")
|
||||
}
|
||||
if a.Stride < a.KL+a.KU+1 {
|
||||
panic("cblas128: short stride for source")
|
||||
}
|
||||
if t.Stride < t.KL+t.KU+1 {
|
||||
panic("cblas128: short stride for destination")
|
||||
}
|
||||
for j := 0; j < a.Cols; j++ {
|
||||
for i := max(0, j-a.KU); i < min(j+a.KL+1, a.Rows); i++ {
|
||||
t.Data[j+a.KL-i+i*a.Stride] = a.Data[i+t.KU-j+j*t.Stride]
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TriangularBandCols represents a symmetric matrix using the band column-major storage scheme.
|
||||
type TriangularBandCols TriangularBand
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions, bandwidth and uplo as a and
|
||||
// have adequate backing data storage.
|
||||
func (t TriangularBandCols) From(a TriangularBand) {
|
||||
if t.N != a.N {
|
||||
panic("cblas128: mismatched dimension")
|
||||
}
|
||||
if t.K != a.K {
|
||||
panic("cblas128: mismatched bandwidth")
|
||||
}
|
||||
if a.Stride < a.K+1 {
|
||||
panic("cblas128: short stride for source")
|
||||
}
|
||||
if t.Stride < t.K+1 {
|
||||
panic("cblas128: short stride for destination")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("cblas128: mismatched BLAS uplo")
|
||||
}
|
||||
if t.Diag != a.Diag {
|
||||
panic("cblas128: mismatched BLAS diag")
|
||||
}
|
||||
dst := BandCols{
|
||||
Rows: t.N, Cols: t.N,
|
||||
Stride: t.Stride,
|
||||
Data: t.Data,
|
||||
}
|
||||
src := Band{
|
||||
Rows: a.N, Cols: a.N,
|
||||
Stride: a.Stride,
|
||||
Data: a.Data,
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("cblas128: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
dst.KU = t.K
|
||||
src.KU = a.K
|
||||
case blas.Lower:
|
||||
dst.KL = t.K
|
||||
src.KL = a.K
|
||||
}
|
||||
dst.From(src)
|
||||
}
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions, bandwidth and uplo as a and
|
||||
// have adequate backing data storage.
|
||||
func (t TriangularBand) From(a TriangularBandCols) {
|
||||
if t.N != a.N {
|
||||
panic("cblas128: mismatched dimension")
|
||||
}
|
||||
if t.K != a.K {
|
||||
panic("cblas128: mismatched bandwidth")
|
||||
}
|
||||
if a.Stride < a.K+1 {
|
||||
panic("cblas128: short stride for source")
|
||||
}
|
||||
if t.Stride < t.K+1 {
|
||||
panic("cblas128: short stride for destination")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("cblas128: mismatched BLAS uplo")
|
||||
}
|
||||
if t.Diag != a.Diag {
|
||||
panic("cblas128: mismatched BLAS diag")
|
||||
}
|
||||
dst := Band{
|
||||
Rows: t.N, Cols: t.N,
|
||||
Stride: t.Stride,
|
||||
Data: t.Data,
|
||||
}
|
||||
src := BandCols{
|
||||
Rows: a.N, Cols: a.N,
|
||||
Stride: a.Stride,
|
||||
Data: a.Data,
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("cblas128: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
dst.KU = t.K
|
||||
src.KU = a.K
|
||||
case blas.Lower:
|
||||
dst.KL = t.K
|
||||
src.KL = a.K
|
||||
}
|
||||
dst.From(src)
|
||||
}
|
||||
|
||||
func min(a, b int) int {
|
||||
if a < b {
|
||||
return a
|
||||
}
|
||||
return b
|
||||
}
|
||||
|
||||
func max(a, b int) int {
|
||||
if a > b {
|
||||
return a
|
||||
}
|
||||
return b
|
||||
}
|
||||
155
vendor/gonum.org/v1/gonum/blas/cblas128/conv_hermitian.go
generated
vendored
Normal file
155
vendor/gonum.org/v1/gonum/blas/cblas128/conv_hermitian.go
generated
vendored
Normal file
@@ -0,0 +1,155 @@
|
||||
// Code generated by "go generate gonum.org/v1/gonum/blas”; DO NOT EDIT.
|
||||
|
||||
// Copyright ©2015 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package cblas128
|
||||
|
||||
import "gonum.org/v1/gonum/blas"
|
||||
|
||||
// HermitianCols represents a matrix using the conventional column-major storage scheme.
|
||||
type HermitianCols Hermitian
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions and uplo as a and have adequate
|
||||
// backing data storage.
|
||||
func (t HermitianCols) From(a Hermitian) {
|
||||
if t.N != a.N {
|
||||
panic("cblas128: mismatched dimension")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("cblas128: mismatched BLAS uplo")
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("cblas128: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := i; j < a.N; j++ {
|
||||
t.Data[i+j*t.Stride] = a.Data[i*a.Stride+j]
|
||||
}
|
||||
}
|
||||
case blas.Lower:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := 0; j <= i; j++ {
|
||||
t.Data[i+j*t.Stride] = a.Data[i*a.Stride+j]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions and uplo as a and have adequate
|
||||
// backing data storage.
|
||||
func (t Hermitian) From(a HermitianCols) {
|
||||
if t.N != a.N {
|
||||
panic("cblas128: mismatched dimension")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("cblas128: mismatched BLAS uplo")
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("cblas128: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := i; j < a.N; j++ {
|
||||
t.Data[i*t.Stride+j] = a.Data[i+j*a.Stride]
|
||||
}
|
||||
}
|
||||
case blas.Lower:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := 0; j <= i; j++ {
|
||||
t.Data[i*t.Stride+j] = a.Data[i+j*a.Stride]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// HermitianBandCols represents an Hermitian matrix using the band column-major storage scheme.
|
||||
type HermitianBandCols HermitianBand
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions, bandwidth and uplo as a and
|
||||
// have adequate backing data storage.
|
||||
func (t HermitianBandCols) From(a HermitianBand) {
|
||||
if t.N != a.N {
|
||||
panic("cblas128: mismatched dimension")
|
||||
}
|
||||
if t.K != a.K {
|
||||
panic("cblas128: mismatched bandwidth")
|
||||
}
|
||||
if a.Stride < a.K+1 {
|
||||
panic("cblas128: short stride for source")
|
||||
}
|
||||
if t.Stride < t.K+1 {
|
||||
panic("cblas128: short stride for destination")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("cblas128: mismatched BLAS uplo")
|
||||
}
|
||||
dst := BandCols{
|
||||
Rows: t.N, Cols: t.N,
|
||||
Stride: t.Stride,
|
||||
Data: t.Data,
|
||||
}
|
||||
src := Band{
|
||||
Rows: a.N, Cols: a.N,
|
||||
Stride: a.Stride,
|
||||
Data: a.Data,
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("cblas128: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
dst.KU = t.K
|
||||
src.KU = a.K
|
||||
case blas.Lower:
|
||||
dst.KL = t.K
|
||||
src.KL = a.K
|
||||
}
|
||||
dst.From(src)
|
||||
}
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions, bandwidth and uplo as a and
|
||||
// have adequate backing data storage.
|
||||
func (t HermitianBand) From(a HermitianBandCols) {
|
||||
if t.N != a.N {
|
||||
panic("cblas128: mismatched dimension")
|
||||
}
|
||||
if t.K != a.K {
|
||||
panic("cblas128: mismatched bandwidth")
|
||||
}
|
||||
if a.Stride < a.K+1 {
|
||||
panic("cblas128: short stride for source")
|
||||
}
|
||||
if t.Stride < t.K+1 {
|
||||
panic("cblas128: short stride for destination")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("cblas128: mismatched BLAS uplo")
|
||||
}
|
||||
dst := Band{
|
||||
Rows: t.N, Cols: t.N,
|
||||
Stride: t.Stride,
|
||||
Data: t.Data,
|
||||
}
|
||||
src := BandCols{
|
||||
Rows: a.N, Cols: a.N,
|
||||
Stride: a.Stride,
|
||||
Data: a.Data,
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("cblas128: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
dst.KU = t.K
|
||||
src.KU = a.K
|
||||
case blas.Lower:
|
||||
dst.KL = t.K
|
||||
src.KL = a.K
|
||||
}
|
||||
dst.From(src)
|
||||
}
|
||||
155
vendor/gonum.org/v1/gonum/blas/cblas128/conv_symmetric.go
generated
vendored
Normal file
155
vendor/gonum.org/v1/gonum/blas/cblas128/conv_symmetric.go
generated
vendored
Normal file
@@ -0,0 +1,155 @@
|
||||
// Code generated by "go generate gonum.org/v1/gonum/blas”; DO NOT EDIT.
|
||||
|
||||
// Copyright ©2015 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package cblas128
|
||||
|
||||
import "gonum.org/v1/gonum/blas"
|
||||
|
||||
// SymmetricCols represents a matrix using the conventional column-major storage scheme.
|
||||
type SymmetricCols Symmetric
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions and uplo as a and have adequate
|
||||
// backing data storage.
|
||||
func (t SymmetricCols) From(a Symmetric) {
|
||||
if t.N != a.N {
|
||||
panic("cblas128: mismatched dimension")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("cblas128: mismatched BLAS uplo")
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("cblas128: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := i; j < a.N; j++ {
|
||||
t.Data[i+j*t.Stride] = a.Data[i*a.Stride+j]
|
||||
}
|
||||
}
|
||||
case blas.Lower:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := 0; j <= i; j++ {
|
||||
t.Data[i+j*t.Stride] = a.Data[i*a.Stride+j]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions and uplo as a and have adequate
|
||||
// backing data storage.
|
||||
func (t Symmetric) From(a SymmetricCols) {
|
||||
if t.N != a.N {
|
||||
panic("cblas128: mismatched dimension")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("cblas128: mismatched BLAS uplo")
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("cblas128: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := i; j < a.N; j++ {
|
||||
t.Data[i*t.Stride+j] = a.Data[i+j*a.Stride]
|
||||
}
|
||||
}
|
||||
case blas.Lower:
|
||||
for i := 0; i < a.N; i++ {
|
||||
for j := 0; j <= i; j++ {
|
||||
t.Data[i*t.Stride+j] = a.Data[i+j*a.Stride]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// SymmetricBandCols represents a symmetric matrix using the band column-major storage scheme.
|
||||
type SymmetricBandCols SymmetricBand
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions, bandwidth and uplo as a and
|
||||
// have adequate backing data storage.
|
||||
func (t SymmetricBandCols) From(a SymmetricBand) {
|
||||
if t.N != a.N {
|
||||
panic("cblas128: mismatched dimension")
|
||||
}
|
||||
if t.K != a.K {
|
||||
panic("cblas128: mismatched bandwidth")
|
||||
}
|
||||
if a.Stride < a.K+1 {
|
||||
panic("cblas128: short stride for source")
|
||||
}
|
||||
if t.Stride < t.K+1 {
|
||||
panic("cblas128: short stride for destination")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("cblas128: mismatched BLAS uplo")
|
||||
}
|
||||
dst := BandCols{
|
||||
Rows: t.N, Cols: t.N,
|
||||
Stride: t.Stride,
|
||||
Data: t.Data,
|
||||
}
|
||||
src := Band{
|
||||
Rows: a.N, Cols: a.N,
|
||||
Stride: a.Stride,
|
||||
Data: a.Data,
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("cblas128: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
dst.KU = t.K
|
||||
src.KU = a.K
|
||||
case blas.Lower:
|
||||
dst.KL = t.K
|
||||
src.KL = a.K
|
||||
}
|
||||
dst.From(src)
|
||||
}
|
||||
|
||||
// From fills the receiver with elements from a. The receiver
|
||||
// must have the same dimensions, bandwidth and uplo as a and
|
||||
// have adequate backing data storage.
|
||||
func (t SymmetricBand) From(a SymmetricBandCols) {
|
||||
if t.N != a.N {
|
||||
panic("cblas128: mismatched dimension")
|
||||
}
|
||||
if t.K != a.K {
|
||||
panic("cblas128: mismatched bandwidth")
|
||||
}
|
||||
if a.Stride < a.K+1 {
|
||||
panic("cblas128: short stride for source")
|
||||
}
|
||||
if t.Stride < t.K+1 {
|
||||
panic("cblas128: short stride for destination")
|
||||
}
|
||||
if t.Uplo != a.Uplo {
|
||||
panic("cblas128: mismatched BLAS uplo")
|
||||
}
|
||||
dst := Band{
|
||||
Rows: t.N, Cols: t.N,
|
||||
Stride: t.Stride,
|
||||
Data: t.Data,
|
||||
}
|
||||
src := BandCols{
|
||||
Rows: a.N, Cols: a.N,
|
||||
Stride: a.Stride,
|
||||
Data: a.Data,
|
||||
}
|
||||
switch a.Uplo {
|
||||
default:
|
||||
panic("cblas128: bad BLAS uplo")
|
||||
case blas.Upper:
|
||||
dst.KU = t.K
|
||||
src.KU = a.K
|
||||
case blas.Lower:
|
||||
dst.KL = t.K
|
||||
src.KL = a.K
|
||||
}
|
||||
dst.From(src)
|
||||
}
|
||||
6
vendor/gonum.org/v1/gonum/blas/cblas128/doc.go
generated
vendored
Normal file
6
vendor/gonum.org/v1/gonum/blas/cblas128/doc.go
generated
vendored
Normal file
@@ -0,0 +1,6 @@
|
||||
// Copyright ©2017 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
// Package cblas128 provides a simple interface to the complex128 BLAS API.
|
||||
package cblas128 // import "gonum.org/v1/gonum/blas/cblas128"
|
||||
159
vendor/gonum.org/v1/gonum/blas/conversions.bash
generated
vendored
Normal file
159
vendor/gonum.org/v1/gonum/blas/conversions.bash
generated
vendored
Normal file
@@ -0,0 +1,159 @@
|
||||
#!/usr/bin/env bash
|
||||
|
||||
# Copyright ©2017 The Gonum Authors. All rights reserved.
|
||||
# Use of this source code is governed by a BSD-style
|
||||
# license that can be found in the LICENSE file.
|
||||
|
||||
# Generate code for blas32.
|
||||
echo Generating blas32/conv.go
|
||||
echo -e '// Code generated by "go generate gonum.org/v1/gonum/blas”; DO NOT EDIT.\n' > blas32/conv.go
|
||||
cat blas64/conv.go \
|
||||
| gofmt -r 'float64 -> float32' \
|
||||
\
|
||||
| sed -e 's/blas64/blas32/' \
|
||||
\
|
||||
>> blas32/conv.go
|
||||
|
||||
echo Generating blas32/conv_test.go
|
||||
echo -e '// Code generated by "go generate gonum.org/v1/gonum/blas”; DO NOT EDIT.\n' > blas32/conv_test.go
|
||||
cat blas64/conv_test.go \
|
||||
| gofmt -r 'float64 -> float32' \
|
||||
\
|
||||
| sed -e 's/blas64/blas32/' \
|
||||
-e 's_"math"_math "gonum.org/v1/gonum/internal/math32"_' \
|
||||
\
|
||||
>> blas32/conv_test.go
|
||||
|
||||
echo Generating blas32/conv_symmetric.go
|
||||
echo -e '// Code generated by "go generate gonum.org/v1/gonum/blas”; DO NOT EDIT.\n' > blas32/conv_symmetric.go
|
||||
cat blas64/conv_symmetric.go \
|
||||
| gofmt -r 'float64 -> float32' \
|
||||
\
|
||||
| sed -e 's/blas64/blas32/' \
|
||||
\
|
||||
>> blas32/conv_symmetric.go
|
||||
|
||||
echo Generating blas32/conv_symmetric_test.go
|
||||
echo -e '// Code generated by "go generate gonum.org/v1/gonum/blas”; DO NOT EDIT.\n' > blas32/conv_symmetric_test.go
|
||||
cat blas64/conv_symmetric_test.go \
|
||||
| gofmt -r 'float64 -> float32' \
|
||||
\
|
||||
| sed -e 's/blas64/blas32/' \
|
||||
-e 's_"math"_math "gonum.org/v1/gonum/internal/math32"_' \
|
||||
\
|
||||
>> blas32/conv_symmetric_test.go
|
||||
|
||||
|
||||
# Generate code for cblas128.
|
||||
echo Generating cblas128/conv.go
|
||||
echo -e '// Code generated by "go generate gonum.org/v1/gonum/blas”; DO NOT EDIT.\n' > cblas128/conv.go
|
||||
cat blas64/conv.go \
|
||||
| gofmt -r 'float64 -> complex128' \
|
||||
\
|
||||
| sed -e 's/blas64/cblas128/' \
|
||||
\
|
||||
>> cblas128/conv.go
|
||||
|
||||
echo Generating cblas128/conv_test.go
|
||||
echo -e '// Code generated by "go generate gonum.org/v1/gonum/blas”; DO NOT EDIT.\n' > cblas128/conv_test.go
|
||||
cat blas64/conv_test.go \
|
||||
| gofmt -r 'float64 -> complex128' \
|
||||
\
|
||||
| sed -e 's/blas64/cblas128/' \
|
||||
-e 's_"math"_math "math/cmplx"_' \
|
||||
\
|
||||
>> cblas128/conv_test.go
|
||||
|
||||
echo Generating cblas128/conv_symmetric.go
|
||||
echo -e '// Code generated by "go generate gonum.org/v1/gonum/blas”; DO NOT EDIT.\n' > cblas128/conv_symmetric.go
|
||||
cat blas64/conv_symmetric.go \
|
||||
| gofmt -r 'float64 -> complex128' \
|
||||
\
|
||||
| sed -e 's/blas64/cblas128/' \
|
||||
\
|
||||
>> cblas128/conv_symmetric.go
|
||||
|
||||
echo Generating cblas128/conv_symmetric_test.go
|
||||
echo -e '// Code generated by "go generate gonum.org/v1/gonum/blas”; DO NOT EDIT.\n' > cblas128/conv_symmetric_test.go
|
||||
cat blas64/conv_symmetric_test.go \
|
||||
| gofmt -r 'float64 -> complex128' \
|
||||
\
|
||||
| sed -e 's/blas64/cblas128/' \
|
||||
-e 's_"math"_math "math/cmplx"_' \
|
||||
\
|
||||
>> cblas128/conv_symmetric_test.go
|
||||
|
||||
echo Generating cblas128/conv_hermitian.go
|
||||
echo -e '// Code generated by "go generate gonum.org/v1/gonum/blas”; DO NOT EDIT.\n' > cblas128/conv_hermitian.go
|
||||
cat blas64/conv_symmetric.go \
|
||||
| gofmt -r 'float64 -> complex128' \
|
||||
\
|
||||
| sed -e 's/blas64/cblas128/' \
|
||||
-e 's/Symmetric/Hermitian/g' \
|
||||
-e 's/a symmetric/an Hermitian/g' \
|
||||
-e 's/symmetric/hermitian/g' \
|
||||
-e 's/Sym/Herm/g' \
|
||||
\
|
||||
>> cblas128/conv_hermitian.go
|
||||
|
||||
echo Generating cblas128/conv_hermitian_test.go
|
||||
echo -e '// Code generated by "go generate gonum.org/v1/gonum/blas”; DO NOT EDIT.\n' > cblas128/conv_hermitian_test.go
|
||||
cat blas64/conv_symmetric_test.go \
|
||||
| gofmt -r 'float64 -> complex128' \
|
||||
\
|
||||
| sed -e 's/blas64/cblas128/' \
|
||||
-e 's/Symmetric/Hermitian/g' \
|
||||
-e 's/a symmetric/an Hermitian/g' \
|
||||
-e 's/symmetric/hermitian/g' \
|
||||
-e 's/Sym/Herm/g' \
|
||||
-e 's_"math"_math "math/cmplx"_' \
|
||||
\
|
||||
>> cblas128/conv_hermitian_test.go
|
||||
|
||||
|
||||
# Generate code for cblas64.
|
||||
echo Generating cblas64/conv.go
|
||||
echo -e '// Code generated by "go generate gonum.org/v1/gonum/blas”; DO NOT EDIT.\n' > cblas64/conv.go
|
||||
cat blas64/conv.go \
|
||||
| gofmt -r 'float64 -> complex64' \
|
||||
\
|
||||
| sed -e 's/blas64/cblas64/' \
|
||||
\
|
||||
>> cblas64/conv.go
|
||||
|
||||
echo Generating cblas64/conv_test.go
|
||||
echo -e '// Code generated by "go generate gonum.org/v1/gonum/blas”; DO NOT EDIT.\n' > cblas64/conv_test.go
|
||||
cat blas64/conv_test.go \
|
||||
| gofmt -r 'float64 -> complex64' \
|
||||
\
|
||||
| sed -e 's/blas64/cblas64/' \
|
||||
-e 's_"math"_math "gonum.org/v1/gonum/internal/cmplx64"_' \
|
||||
\
|
||||
>> cblas64/conv_test.go
|
||||
|
||||
echo Generating cblas64/conv_hermitian.go
|
||||
echo -e '// Code generated by "go generate gonum.org/v1/gonum/blas”; DO NOT EDIT.\n' > cblas64/conv_hermitian.go
|
||||
cat blas64/conv_symmetric.go \
|
||||
| gofmt -r 'float64 -> complex64' \
|
||||
\
|
||||
| sed -e 's/blas64/cblas64/' \
|
||||
-e 's/Symmetric/Hermitian/g' \
|
||||
-e 's/a symmetric/an Hermitian/g' \
|
||||
-e 's/symmetric/hermitian/g' \
|
||||
-e 's/Sym/Herm/g' \
|
||||
\
|
||||
>> cblas64/conv_hermitian.go
|
||||
|
||||
echo Generating cblas64/conv_hermitian_test.go
|
||||
echo -e '// Code generated by "go generate gonum.org/v1/gonum/blas”; DO NOT EDIT.\n' > cblas64/conv_hermitian_test.go
|
||||
cat blas64/conv_symmetric_test.go \
|
||||
| gofmt -r 'float64 -> complex64' \
|
||||
\
|
||||
| sed -e 's/blas64/cblas64/' \
|
||||
-e 's/Symmetric/Hermitian/g' \
|
||||
-e 's/a symmetric/an Hermitian/g' \
|
||||
-e 's/symmetric/hermitian/g' \
|
||||
-e 's/Sym/Herm/g' \
|
||||
-e 's_"math"_math "gonum.org/v1/gonum/internal/cmplx64"_' \
|
||||
\
|
||||
>> cblas64/conv_hermitian_test.go
|
||||
108
vendor/gonum.org/v1/gonum/blas/doc.go
generated
vendored
Normal file
108
vendor/gonum.org/v1/gonum/blas/doc.go
generated
vendored
Normal file
@@ -0,0 +1,108 @@
|
||||
// Copyright ©2017 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
/*
|
||||
Package blas provides interfaces for the BLAS linear algebra standard.
|
||||
|
||||
All methods must perform appropriate parameter checking and panic if
|
||||
provided parameters that do not conform to the requirements specified
|
||||
by the BLAS standard.
|
||||
|
||||
Quick Reference Guide to the BLAS from http://www.netlib.org/lapack/lug/node145.html
|
||||
|
||||
This version is modified to remove the "order" option. All matrix operations are
|
||||
on row-order matrices.
|
||||
|
||||
Level 1 BLAS
|
||||
|
||||
dim scalar vector vector scalars 5-element prefixes
|
||||
struct
|
||||
|
||||
_rotg ( a, b ) S, D
|
||||
_rotmg( d1, d2, a, b ) S, D
|
||||
_rot ( n, x, incX, y, incY, c, s ) S, D
|
||||
_rotm ( n, x, incX, y, incY, param ) S, D
|
||||
_swap ( n, x, incX, y, incY ) S, D, C, Z
|
||||
_scal ( n, alpha, x, incX ) S, D, C, Z, Cs, Zd
|
||||
_copy ( n, x, incX, y, incY ) S, D, C, Z
|
||||
_axpy ( n, alpha, x, incX, y, incY ) S, D, C, Z
|
||||
_dot ( n, x, incX, y, incY ) S, D, Ds
|
||||
_dotu ( n, x, incX, y, incY ) C, Z
|
||||
_dotc ( n, x, incX, y, incY ) C, Z
|
||||
__dot ( n, alpha, x, incX, y, incY ) Sds
|
||||
_nrm2 ( n, x, incX ) S, D, Sc, Dz
|
||||
_asum ( n, x, incX ) S, D, Sc, Dz
|
||||
I_amax( n, x, incX ) s, d, c, z
|
||||
|
||||
Level 2 BLAS
|
||||
|
||||
options dim b-width scalar matrix vector scalar vector prefixes
|
||||
|
||||
_gemv ( trans, m, n, alpha, a, lda, x, incX, beta, y, incY ) S, D, C, Z
|
||||
_gbmv ( trans, m, n, kL, kU, alpha, a, lda, x, incX, beta, y, incY ) S, D, C, Z
|
||||
_hemv ( uplo, n, alpha, a, lda, x, incX, beta, y, incY ) C, Z
|
||||
_hbmv ( uplo, n, k, alpha, a, lda, x, incX, beta, y, incY ) C, Z
|
||||
_hpmv ( uplo, n, alpha, ap, x, incX, beta, y, incY ) C, Z
|
||||
_symv ( uplo, n, alpha, a, lda, x, incX, beta, y, incY ) S, D
|
||||
_sbmv ( uplo, n, k, alpha, a, lda, x, incX, beta, y, incY ) S, D
|
||||
_spmv ( uplo, n, alpha, ap, x, incX, beta, y, incY ) S, D
|
||||
_trmv ( uplo, trans, diag, n, a, lda, x, incX ) S, D, C, Z
|
||||
_tbmv ( uplo, trans, diag, n, k, a, lda, x, incX ) S, D, C, Z
|
||||
_tpmv ( uplo, trans, diag, n, ap, x, incX ) S, D, C, Z
|
||||
_trsv ( uplo, trans, diag, n, a, lda, x, incX ) S, D, C, Z
|
||||
_tbsv ( uplo, trans, diag, n, k, a, lda, x, incX ) S, D, C, Z
|
||||
_tpsv ( uplo, trans, diag, n, ap, x, incX ) S, D, C, Z
|
||||
|
||||
options dim scalar vector vector matrix prefixes
|
||||
|
||||
_ger ( m, n, alpha, x, incX, y, incY, a, lda ) S, D
|
||||
_geru ( m, n, alpha, x, incX, y, incY, a, lda ) C, Z
|
||||
_gerc ( m, n, alpha, x, incX, y, incY, a, lda ) C, Z
|
||||
_her ( uplo, n, alpha, x, incX, a, lda ) C, Z
|
||||
_hpr ( uplo, n, alpha, x, incX, ap ) C, Z
|
||||
_her2 ( uplo, n, alpha, x, incX, y, incY, a, lda ) C, Z
|
||||
_hpr2 ( uplo, n, alpha, x, incX, y, incY, ap ) C, Z
|
||||
_syr ( uplo, n, alpha, x, incX, a, lda ) S, D
|
||||
_spr ( uplo, n, alpha, x, incX, ap ) S, D
|
||||
_syr2 ( uplo, n, alpha, x, incX, y, incY, a, lda ) S, D
|
||||
_spr2 ( uplo, n, alpha, x, incX, y, incY, ap ) S, D
|
||||
|
||||
Level 3 BLAS
|
||||
|
||||
options dim scalar matrix matrix scalar matrix prefixes
|
||||
|
||||
_gemm ( transA, transB, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc ) S, D, C, Z
|
||||
_symm ( side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc ) S, D, C, Z
|
||||
_hemm ( side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc ) C, Z
|
||||
_syrk ( uplo, trans, n, k, alpha, a, lda, beta, c, ldc ) S, D, C, Z
|
||||
_herk ( uplo, trans, n, k, alpha, a, lda, beta, c, ldc ) C, Z
|
||||
_syr2k( uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc ) S, D, C, Z
|
||||
_her2k( uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc ) C, Z
|
||||
_trmm ( side, uplo, transA, diag, m, n, alpha, a, lda, b, ldb ) S, D, C, Z
|
||||
_trsm ( side, uplo, transA, diag, m, n, alpha, a, lda, b, ldb ) S, D, C, Z
|
||||
|
||||
Meaning of prefixes
|
||||
|
||||
S - float32 C - complex64
|
||||
D - float64 Z - complex128
|
||||
|
||||
Matrix types
|
||||
|
||||
GE - GEneral GB - General Band
|
||||
SY - SYmmetric SB - Symmetric Band SP - Symmetric Packed
|
||||
HE - HErmitian HB - Hermitian Band HP - Hermitian Packed
|
||||
TR - TRiangular TB - Triangular Band TP - Triangular Packed
|
||||
|
||||
Options
|
||||
|
||||
trans = NoTrans, Trans, ConjTrans
|
||||
uplo = Upper, Lower
|
||||
diag = Nonunit, Unit
|
||||
side = Left, Right (A or op(A) on the left, or A or op(A) on the right)
|
||||
|
||||
For real matrices, Trans and ConjTrans have the same meaning.
|
||||
For Hermitian matrices, trans = Trans is not allowed.
|
||||
For complex symmetric matrices, trans = ConjTrans is not allowed.
|
||||
*/
|
||||
package blas // import "gonum.org/v1/gonum/blas"
|
||||
314
vendor/gonum.org/v1/gonum/blas/gonum/dgemm.go
generated
vendored
Normal file
314
vendor/gonum.org/v1/gonum/blas/gonum/dgemm.go
generated
vendored
Normal file
@@ -0,0 +1,314 @@
|
||||
// Copyright ©2014 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package gonum
|
||||
|
||||
import (
|
||||
"runtime"
|
||||
"sync"
|
||||
|
||||
"gonum.org/v1/gonum/blas"
|
||||
"gonum.org/v1/gonum/internal/asm/f64"
|
||||
)
|
||||
|
||||
// Dgemm performs one of the matrix-matrix operations
|
||||
// C = alpha * A * B + beta * C
|
||||
// C = alpha * A^T * B + beta * C
|
||||
// C = alpha * A * B^T + beta * C
|
||||
// C = alpha * A^T * B^T + beta * C
|
||||
// where A is an m×k or k×m dense matrix, B is an n×k or k×n dense matrix, C is
|
||||
// an m×n matrix, and alpha and beta are scalars. tA and tB specify whether A or
|
||||
// B are transposed.
|
||||
func (Implementation) Dgemm(tA, tB blas.Transpose, m, n, k int, alpha float64, a []float64, lda int, b []float64, ldb int, beta float64, c []float64, ldc int) {
|
||||
switch tA {
|
||||
default:
|
||||
panic(badTranspose)
|
||||
case blas.NoTrans, blas.Trans, blas.ConjTrans:
|
||||
}
|
||||
switch tB {
|
||||
default:
|
||||
panic(badTranspose)
|
||||
case blas.NoTrans, blas.Trans, blas.ConjTrans:
|
||||
}
|
||||
if m < 0 {
|
||||
panic(mLT0)
|
||||
}
|
||||
if n < 0 {
|
||||
panic(nLT0)
|
||||
}
|
||||
if k < 0 {
|
||||
panic(kLT0)
|
||||
}
|
||||
aTrans := tA == blas.Trans || tA == blas.ConjTrans
|
||||
if aTrans {
|
||||
if lda < max(1, m) {
|
||||
panic(badLdA)
|
||||
}
|
||||
} else {
|
||||
if lda < max(1, k) {
|
||||
panic(badLdA)
|
||||
}
|
||||
}
|
||||
bTrans := tB == blas.Trans || tB == blas.ConjTrans
|
||||
if bTrans {
|
||||
if ldb < max(1, k) {
|
||||
panic(badLdB)
|
||||
}
|
||||
} else {
|
||||
if ldb < max(1, n) {
|
||||
panic(badLdB)
|
||||
}
|
||||
}
|
||||
if ldc < max(1, n) {
|
||||
panic(badLdC)
|
||||
}
|
||||
|
||||
// Quick return if possible.
|
||||
if m == 0 || n == 0 {
|
||||
return
|
||||
}
|
||||
|
||||
// For zero matrix size the following slice length checks are trivially satisfied.
|
||||
if aTrans {
|
||||
if len(a) < (k-1)*lda+m {
|
||||
panic(shortA)
|
||||
}
|
||||
} else {
|
||||
if len(a) < (m-1)*lda+k {
|
||||
panic(shortA)
|
||||
}
|
||||
}
|
||||
if bTrans {
|
||||
if len(b) < (n-1)*ldb+k {
|
||||
panic(shortB)
|
||||
}
|
||||
} else {
|
||||
if len(b) < (k-1)*ldb+n {
|
||||
panic(shortB)
|
||||
}
|
||||
}
|
||||
if len(c) < (m-1)*ldc+n {
|
||||
panic(shortC)
|
||||
}
|
||||
|
||||
// Quick return if possible.
|
||||
if (alpha == 0 || k == 0) && beta == 1 {
|
||||
return
|
||||
}
|
||||
|
||||
// scale c
|
||||
if beta != 1 {
|
||||
if beta == 0 {
|
||||
for i := 0; i < m; i++ {
|
||||
ctmp := c[i*ldc : i*ldc+n]
|
||||
for j := range ctmp {
|
||||
ctmp[j] = 0
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for i := 0; i < m; i++ {
|
||||
ctmp := c[i*ldc : i*ldc+n]
|
||||
for j := range ctmp {
|
||||
ctmp[j] *= beta
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
dgemmParallel(aTrans, bTrans, m, n, k, a, lda, b, ldb, c, ldc, alpha)
|
||||
}
|
||||
|
||||
func dgemmParallel(aTrans, bTrans bool, m, n, k int, a []float64, lda int, b []float64, ldb int, c []float64, ldc int, alpha float64) {
|
||||
// dgemmParallel computes a parallel matrix multiplication by partitioning
|
||||
// a and b into sub-blocks, and updating c with the multiplication of the sub-block
|
||||
// In all cases,
|
||||
// A = [ A_11 A_12 ... A_1j
|
||||
// A_21 A_22 ... A_2j
|
||||
// ...
|
||||
// A_i1 A_i2 ... A_ij]
|
||||
//
|
||||
// and same for B. All of the submatrix sizes are blockSize×blockSize except
|
||||
// at the edges.
|
||||
//
|
||||
// In all cases, there is one dimension for each matrix along which
|
||||
// C must be updated sequentially.
|
||||
// Cij = \sum_k Aik Bki, (A * B)
|
||||
// Cij = \sum_k Aki Bkj, (A^T * B)
|
||||
// Cij = \sum_k Aik Bjk, (A * B^T)
|
||||
// Cij = \sum_k Aki Bjk, (A^T * B^T)
|
||||
//
|
||||
// This code computes one {i, j} block sequentially along the k dimension,
|
||||
// and computes all of the {i, j} blocks concurrently. This
|
||||
// partitioning allows Cij to be updated in-place without race-conditions.
|
||||
// Instead of launching a goroutine for each possible concurrent computation,
|
||||
// a number of worker goroutines are created and channels are used to pass
|
||||
// available and completed cases.
|
||||
//
|
||||
// http://alexkr.com/docs/matrixmult.pdf is a good reference on matrix-matrix
|
||||
// multiplies, though this code does not copy matrices to attempt to eliminate
|
||||
// cache misses.
|
||||
|
||||
maxKLen := k
|
||||
parBlocks := blocks(m, blockSize) * blocks(n, blockSize)
|
||||
if parBlocks < minParBlock {
|
||||
// The matrix multiplication is small in the dimensions where it can be
|
||||
// computed concurrently. Just do it in serial.
|
||||
dgemmSerial(aTrans, bTrans, m, n, k, a, lda, b, ldb, c, ldc, alpha)
|
||||
return
|
||||
}
|
||||
|
||||
nWorkers := runtime.GOMAXPROCS(0)
|
||||
if parBlocks < nWorkers {
|
||||
nWorkers = parBlocks
|
||||
}
|
||||
// There is a tradeoff between the workers having to wait for work
|
||||
// and a large buffer making operations slow.
|
||||
buf := buffMul * nWorkers
|
||||
if buf > parBlocks {
|
||||
buf = parBlocks
|
||||
}
|
||||
|
||||
sendChan := make(chan subMul, buf)
|
||||
|
||||
// Launch workers. A worker receives an {i, j} submatrix of c, and computes
|
||||
// A_ik B_ki (or the transposed version) storing the result in c_ij. When the
|
||||
// channel is finally closed, it signals to the waitgroup that it has finished
|
||||
// computing.
|
||||
var wg sync.WaitGroup
|
||||
for i := 0; i < nWorkers; i++ {
|
||||
wg.Add(1)
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
for sub := range sendChan {
|
||||
i := sub.i
|
||||
j := sub.j
|
||||
leni := blockSize
|
||||
if i+leni > m {
|
||||
leni = m - i
|
||||
}
|
||||
lenj := blockSize
|
||||
if j+lenj > n {
|
||||
lenj = n - j
|
||||
}
|
||||
|
||||
cSub := sliceView64(c, ldc, i, j, leni, lenj)
|
||||
|
||||
// Compute A_ik B_kj for all k
|
||||
for k := 0; k < maxKLen; k += blockSize {
|
||||
lenk := blockSize
|
||||
if k+lenk > maxKLen {
|
||||
lenk = maxKLen - k
|
||||
}
|
||||
var aSub, bSub []float64
|
||||
if aTrans {
|
||||
aSub = sliceView64(a, lda, k, i, lenk, leni)
|
||||
} else {
|
||||
aSub = sliceView64(a, lda, i, k, leni, lenk)
|
||||
}
|
||||
if bTrans {
|
||||
bSub = sliceView64(b, ldb, j, k, lenj, lenk)
|
||||
} else {
|
||||
bSub = sliceView64(b, ldb, k, j, lenk, lenj)
|
||||
}
|
||||
dgemmSerial(aTrans, bTrans, leni, lenj, lenk, aSub, lda, bSub, ldb, cSub, ldc, alpha)
|
||||
}
|
||||
}
|
||||
}()
|
||||
}
|
||||
|
||||
// Send out all of the {i, j} subblocks for computation.
|
||||
for i := 0; i < m; i += blockSize {
|
||||
for j := 0; j < n; j += blockSize {
|
||||
sendChan <- subMul{
|
||||
i: i,
|
||||
j: j,
|
||||
}
|
||||
}
|
||||
}
|
||||
close(sendChan)
|
||||
wg.Wait()
|
||||
}
|
||||
|
||||
// dgemmSerial is serial matrix multiply
|
||||
func dgemmSerial(aTrans, bTrans bool, m, n, k int, a []float64, lda int, b []float64, ldb int, c []float64, ldc int, alpha float64) {
|
||||
switch {
|
||||
case !aTrans && !bTrans:
|
||||
dgemmSerialNotNot(m, n, k, a, lda, b, ldb, c, ldc, alpha)
|
||||
return
|
||||
case aTrans && !bTrans:
|
||||
dgemmSerialTransNot(m, n, k, a, lda, b, ldb, c, ldc, alpha)
|
||||
return
|
||||
case !aTrans && bTrans:
|
||||
dgemmSerialNotTrans(m, n, k, a, lda, b, ldb, c, ldc, alpha)
|
||||
return
|
||||
case aTrans && bTrans:
|
||||
dgemmSerialTransTrans(m, n, k, a, lda, b, ldb, c, ldc, alpha)
|
||||
return
|
||||
default:
|
||||
panic("unreachable")
|
||||
}
|
||||
}
|
||||
|
||||
// dgemmSerial where neither a nor b are transposed
|
||||
func dgemmSerialNotNot(m, n, k int, a []float64, lda int, b []float64, ldb int, c []float64, ldc int, alpha float64) {
|
||||
// This style is used instead of the literal [i*stride +j]) is used because
|
||||
// approximately 5 times faster as of go 1.3.
|
||||
for i := 0; i < m; i++ {
|
||||
ctmp := c[i*ldc : i*ldc+n]
|
||||
for l, v := range a[i*lda : i*lda+k] {
|
||||
tmp := alpha * v
|
||||
if tmp != 0 {
|
||||
f64.AxpyUnitary(tmp, b[l*ldb:l*ldb+n], ctmp)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// dgemmSerial where neither a is transposed and b is not
|
||||
func dgemmSerialTransNot(m, n, k int, a []float64, lda int, b []float64, ldb int, c []float64, ldc int, alpha float64) {
|
||||
// This style is used instead of the literal [i*stride +j]) is used because
|
||||
// approximately 5 times faster as of go 1.3.
|
||||
for l := 0; l < k; l++ {
|
||||
btmp := b[l*ldb : l*ldb+n]
|
||||
for i, v := range a[l*lda : l*lda+m] {
|
||||
tmp := alpha * v
|
||||
if tmp != 0 {
|
||||
ctmp := c[i*ldc : i*ldc+n]
|
||||
f64.AxpyUnitary(tmp, btmp, ctmp)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// dgemmSerial where neither a is not transposed and b is
|
||||
func dgemmSerialNotTrans(m, n, k int, a []float64, lda int, b []float64, ldb int, c []float64, ldc int, alpha float64) {
|
||||
// This style is used instead of the literal [i*stride +j]) is used because
|
||||
// approximately 5 times faster as of go 1.3.
|
||||
for i := 0; i < m; i++ {
|
||||
atmp := a[i*lda : i*lda+k]
|
||||
ctmp := c[i*ldc : i*ldc+n]
|
||||
for j := 0; j < n; j++ {
|
||||
ctmp[j] += alpha * f64.DotUnitary(atmp, b[j*ldb:j*ldb+k])
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// dgemmSerial where both are transposed
|
||||
func dgemmSerialTransTrans(m, n, k int, a []float64, lda int, b []float64, ldb int, c []float64, ldc int, alpha float64) {
|
||||
// This style is used instead of the literal [i*stride +j]) is used because
|
||||
// approximately 5 times faster as of go 1.3.
|
||||
for l := 0; l < k; l++ {
|
||||
for i, v := range a[l*lda : l*lda+m] {
|
||||
tmp := alpha * v
|
||||
if tmp != 0 {
|
||||
ctmp := c[i*ldc : i*ldc+n]
|
||||
f64.AxpyInc(tmp, b[l:], ctmp, uintptr(n), uintptr(ldb), 1, 0, 0)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func sliceView64(a []float64, lda, i, j, r, c int) []float64 {
|
||||
return a[i*lda+j : (i+r-1)*lda+j+c]
|
||||
}
|
||||
88
vendor/gonum.org/v1/gonum/blas/gonum/doc.go
generated
vendored
Normal file
88
vendor/gonum.org/v1/gonum/blas/gonum/doc.go
generated
vendored
Normal file
@@ -0,0 +1,88 @@
|
||||
// Copyright ©2015 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
// Ensure changes made to blas/native are reflected in blas/cgo where relevant.
|
||||
|
||||
/*
|
||||
Package gonum is a Go implementation of the BLAS API. This implementation
|
||||
panics when the input arguments are invalid as per the standard, for example
|
||||
if a vector increment is zero. Note that the treatment of NaN values
|
||||
is not specified, and differs among the BLAS implementations.
|
||||
gonum.org/v1/gonum/blas/blas64 provides helpful wrapper functions to the BLAS
|
||||
interface. The rest of this text describes the layout of the data for the input types.
|
||||
|
||||
Note that in the function documentation, x[i] refers to the i^th element
|
||||
of the vector, which will be different from the i^th element of the slice if
|
||||
incX != 1.
|
||||
|
||||
See http://www.netlib.org/lapack/explore-html/d4/de1/_l_i_c_e_n_s_e_source.html
|
||||
for more license information.
|
||||
|
||||
Vector arguments are effectively strided slices. They have two input arguments,
|
||||
a number of elements, n, and an increment, incX. The increment specifies the
|
||||
distance between elements of the vector. The actual Go slice may be longer
|
||||
than necessary.
|
||||
The increment may be positive or negative, except in functions with only
|
||||
a single vector argument where the increment may only be positive. If the increment
|
||||
is negative, s[0] is the last element in the slice. Note that this is not the same
|
||||
as counting backward from the end of the slice, as len(s) may be longer than
|
||||
necessary. So, for example, if n = 5 and incX = 3, the elements of s are
|
||||
[0 * * 1 * * 2 * * 3 * * 4 * * * ...]
|
||||
where ∗ elements are never accessed. If incX = -3, the same elements are
|
||||
accessed, just in reverse order (4, 3, 2, 1, 0).
|
||||
|
||||
Dense matrices are specified by a number of rows, a number of columns, and a stride.
|
||||
The stride specifies the number of entries in the slice between the first element
|
||||
of successive rows. The stride must be at least as large as the number of columns
|
||||
but may be longer.
|
||||
[a00 ... a0n a0* ... a1stride-1 a21 ... amn am* ... amstride-1]
|
||||
Thus, dense[i*ld + j] refers to the {i, j}th element of the matrix.
|
||||
|
||||
Symmetric and triangular matrices (non-packed) are stored identically to Dense,
|
||||
except that only elements in one triangle of the matrix are accessed.
|
||||
|
||||
Packed symmetric and packed triangular matrices are laid out with the entries
|
||||
condensed such that all of the unreferenced elements are removed. So, the upper triangular
|
||||
matrix
|
||||
[
|
||||
1 2 3
|
||||
0 4 5
|
||||
0 0 6
|
||||
]
|
||||
and the lower-triangular matrix
|
||||
[
|
||||
1 0 0
|
||||
2 3 0
|
||||
4 5 6
|
||||
]
|
||||
will both be compacted as [1 2 3 4 5 6]. The (i, j) element of the original
|
||||
dense matrix can be found at element i*n - (i-1)*i/2 + j for upper triangular,
|
||||
and at element i * (i+1) /2 + j for lower triangular.
|
||||
|
||||
Banded matrices are laid out in a compact format, constructed by removing the
|
||||
zeros in the rows and aligning the diagonals. For example, the matrix
|
||||
[
|
||||
1 2 3 0 0 0
|
||||
4 5 6 7 0 0
|
||||
0 8 9 10 11 0
|
||||
0 0 12 13 14 15
|
||||
0 0 0 16 17 18
|
||||
0 0 0 0 19 20
|
||||
]
|
||||
|
||||
implicitly becomes (∗ entries are never accessed)
|
||||
[
|
||||
* 1 2 3
|
||||
4 5 6 7
|
||||
8 9 10 11
|
||||
12 13 14 15
|
||||
16 17 18 *
|
||||
19 20 * *
|
||||
]
|
||||
which is given to the BLAS routine as [∗ 1 2 3 4 ...].
|
||||
|
||||
See http://www.crest.iu.edu/research/mtl/reference/html/banded.html
|
||||
for more information
|
||||
*/
|
||||
package gonum // import "gonum.org/v1/gonum/blas/gonum"
|
||||
35
vendor/gonum.org/v1/gonum/blas/gonum/errors.go
generated
vendored
Normal file
35
vendor/gonum.org/v1/gonum/blas/gonum/errors.go
generated
vendored
Normal file
@@ -0,0 +1,35 @@
|
||||
// Copyright ©2015 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package gonum
|
||||
|
||||
// Panic strings used during parameter checks.
|
||||
// This list is duplicated in netlib/blas/netlib. Keep in sync.
|
||||
const (
|
||||
zeroIncX = "blas: zero x index increment"
|
||||
zeroIncY = "blas: zero y index increment"
|
||||
|
||||
mLT0 = "blas: m < 0"
|
||||
nLT0 = "blas: n < 0"
|
||||
kLT0 = "blas: k < 0"
|
||||
kLLT0 = "blas: kL < 0"
|
||||
kULT0 = "blas: kU < 0"
|
||||
|
||||
badUplo = "blas: illegal triangle"
|
||||
badTranspose = "blas: illegal transpose"
|
||||
badDiag = "blas: illegal diagonal"
|
||||
badSide = "blas: illegal side"
|
||||
badFlag = "blas: illegal rotm flag"
|
||||
|
||||
badLdA = "blas: bad leading dimension of A"
|
||||
badLdB = "blas: bad leading dimension of B"
|
||||
badLdC = "blas: bad leading dimension of C"
|
||||
|
||||
shortX = "blas: insufficient length of x"
|
||||
shortY = "blas: insufficient length of y"
|
||||
shortAP = "blas: insufficient length of ap"
|
||||
shortA = "blas: insufficient length of a"
|
||||
shortB = "blas: insufficient length of b"
|
||||
shortC = "blas: insufficient length of c"
|
||||
)
|
||||
190
vendor/gonum.org/v1/gonum/blas/gonum/gemv.go
generated
vendored
Normal file
190
vendor/gonum.org/v1/gonum/blas/gonum/gemv.go
generated
vendored
Normal file
@@ -0,0 +1,190 @@
|
||||
// Copyright ©2018 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package gonum
|
||||
|
||||
import (
|
||||
"gonum.org/v1/gonum/blas"
|
||||
"gonum.org/v1/gonum/internal/asm/f32"
|
||||
"gonum.org/v1/gonum/internal/asm/f64"
|
||||
)
|
||||
|
||||
// TODO(Kunde21): Merge these methods back into level2double/level2single when Sgemv assembly kernels are merged into f32.
|
||||
|
||||
// Dgemv computes
|
||||
// y = alpha * A * x + beta * y if tA = blas.NoTrans
|
||||
// y = alpha * A^T * x + beta * y if tA = blas.Trans or blas.ConjTrans
|
||||
// where A is an m×n dense matrix, x and y are vectors, and alpha and beta are scalars.
|
||||
func (Implementation) Dgemv(tA blas.Transpose, m, n int, alpha float64, a []float64, lda int, x []float64, incX int, beta float64, y []float64, incY int) {
|
||||
if tA != blas.NoTrans && tA != blas.Trans && tA != blas.ConjTrans {
|
||||
panic(badTranspose)
|
||||
}
|
||||
if m < 0 {
|
||||
panic(mLT0)
|
||||
}
|
||||
if n < 0 {
|
||||
panic(nLT0)
|
||||
}
|
||||
if lda < max(1, n) {
|
||||
panic(badLdA)
|
||||
}
|
||||
if incX == 0 {
|
||||
panic(zeroIncX)
|
||||
}
|
||||
if incY == 0 {
|
||||
panic(zeroIncY)
|
||||
}
|
||||
// Set up indexes
|
||||
lenX := m
|
||||
lenY := n
|
||||
if tA == blas.NoTrans {
|
||||
lenX = n
|
||||
lenY = m
|
||||
}
|
||||
|
||||
// Quick return if possible
|
||||
if m == 0 || n == 0 {
|
||||
return
|
||||
}
|
||||
|
||||
if (incX > 0 && (lenX-1)*incX >= len(x)) || (incX < 0 && (1-lenX)*incX >= len(x)) {
|
||||
panic(shortX)
|
||||
}
|
||||
if (incY > 0 && (lenY-1)*incY >= len(y)) || (incY < 0 && (1-lenY)*incY >= len(y)) {
|
||||
panic(shortY)
|
||||
}
|
||||
if len(a) < lda*(m-1)+n {
|
||||
panic(shortA)
|
||||
}
|
||||
|
||||
// Quick return if possible
|
||||
if alpha == 0 && beta == 1 {
|
||||
return
|
||||
}
|
||||
|
||||
if alpha == 0 {
|
||||
// First form y = beta * y
|
||||
if incY > 0 {
|
||||
Implementation{}.Dscal(lenY, beta, y, incY)
|
||||
} else {
|
||||
Implementation{}.Dscal(lenY, beta, y, -incY)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// Form y = alpha * A * x + y
|
||||
if tA == blas.NoTrans {
|
||||
f64.GemvN(uintptr(m), uintptr(n), alpha, a, uintptr(lda), x, uintptr(incX), beta, y, uintptr(incY))
|
||||
return
|
||||
}
|
||||
// Cases where a is transposed.
|
||||
f64.GemvT(uintptr(m), uintptr(n), alpha, a, uintptr(lda), x, uintptr(incX), beta, y, uintptr(incY))
|
||||
}
|
||||
|
||||
// Sgemv computes
|
||||
// y = alpha * A * x + beta * y if tA = blas.NoTrans
|
||||
// y = alpha * A^T * x + beta * y if tA = blas.Trans or blas.ConjTrans
|
||||
// where A is an m×n dense matrix, x and y are vectors, and alpha and beta are scalars.
|
||||
//
|
||||
// Float32 implementations are autogenerated and not directly tested.
|
||||
func (Implementation) Sgemv(tA blas.Transpose, m, n int, alpha float32, a []float32, lda int, x []float32, incX int, beta float32, y []float32, incY int) {
|
||||
if tA != blas.NoTrans && tA != blas.Trans && tA != blas.ConjTrans {
|
||||
panic(badTranspose)
|
||||
}
|
||||
if m < 0 {
|
||||
panic(mLT0)
|
||||
}
|
||||
if n < 0 {
|
||||
panic(nLT0)
|
||||
}
|
||||
if lda < max(1, n) {
|
||||
panic(badLdA)
|
||||
}
|
||||
if incX == 0 {
|
||||
panic(zeroIncX)
|
||||
}
|
||||
if incY == 0 {
|
||||
panic(zeroIncY)
|
||||
}
|
||||
|
||||
// Quick return if possible.
|
||||
if m == 0 || n == 0 {
|
||||
return
|
||||
}
|
||||
|
||||
// Set up indexes
|
||||
lenX := m
|
||||
lenY := n
|
||||
if tA == blas.NoTrans {
|
||||
lenX = n
|
||||
lenY = m
|
||||
}
|
||||
if (incX > 0 && (lenX-1)*incX >= len(x)) || (incX < 0 && (1-lenX)*incX >= len(x)) {
|
||||
panic(shortX)
|
||||
}
|
||||
if (incY > 0 && (lenY-1)*incY >= len(y)) || (incY < 0 && (1-lenY)*incY >= len(y)) {
|
||||
panic(shortY)
|
||||
}
|
||||
if len(a) < lda*(m-1)+n {
|
||||
panic(shortA)
|
||||
}
|
||||
|
||||
// Quick return if possible.
|
||||
if alpha == 0 && beta == 1 {
|
||||
return
|
||||
}
|
||||
|
||||
// First form y = beta * y
|
||||
if incY > 0 {
|
||||
Implementation{}.Sscal(lenY, beta, y, incY)
|
||||
} else {
|
||||
Implementation{}.Sscal(lenY, beta, y, -incY)
|
||||
}
|
||||
|
||||
if alpha == 0 {
|
||||
return
|
||||
}
|
||||
|
||||
var kx, ky int
|
||||
if incX < 0 {
|
||||
kx = -(lenX - 1) * incX
|
||||
}
|
||||
if incY < 0 {
|
||||
ky = -(lenY - 1) * incY
|
||||
}
|
||||
|
||||
// Form y = alpha * A * x + y
|
||||
if tA == blas.NoTrans {
|
||||
if incX == 1 && incY == 1 {
|
||||
for i := 0; i < m; i++ {
|
||||
y[i] += alpha * f32.DotUnitary(a[lda*i:lda*i+n], x[:n])
|
||||
}
|
||||
return
|
||||
}
|
||||
iy := ky
|
||||
for i := 0; i < m; i++ {
|
||||
y[iy] += alpha * f32.DotInc(x, a[lda*i:lda*i+n], uintptr(n), uintptr(incX), 1, uintptr(kx), 0)
|
||||
iy += incY
|
||||
}
|
||||
return
|
||||
}
|
||||
// Cases where a is transposed.
|
||||
if incX == 1 && incY == 1 {
|
||||
for i := 0; i < m; i++ {
|
||||
tmp := alpha * x[i]
|
||||
if tmp != 0 {
|
||||
f32.AxpyUnitaryTo(y, tmp, a[lda*i:lda*i+n], y[:n])
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
ix := kx
|
||||
for i := 0; i < m; i++ {
|
||||
tmp := alpha * x[ix]
|
||||
if tmp != 0 {
|
||||
f32.AxpyInc(tmp, a[lda*i:lda*i+n], y, uintptr(n), 1, uintptr(incY), 0, uintptr(ky))
|
||||
}
|
||||
ix += incX
|
||||
}
|
||||
}
|
||||
58
vendor/gonum.org/v1/gonum/blas/gonum/gonum.go
generated
vendored
Normal file
58
vendor/gonum.org/v1/gonum/blas/gonum/gonum.go
generated
vendored
Normal file
@@ -0,0 +1,58 @@
|
||||
// Copyright ©2015 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
//go:generate ./single_precision.bash
|
||||
|
||||
package gonum
|
||||
|
||||
import (
|
||||
"math"
|
||||
|
||||
"gonum.org/v1/gonum/internal/math32"
|
||||
)
|
||||
|
||||
type Implementation struct{}
|
||||
|
||||
// [SD]gemm behavior constants. These are kept here to keep them out of the
|
||||
// way during single precision code genration.
|
||||
const (
|
||||
blockSize = 64 // b x b matrix
|
||||
minParBlock = 4 // minimum number of blocks needed to go parallel
|
||||
buffMul = 4 // how big is the buffer relative to the number of workers
|
||||
)
|
||||
|
||||
// subMul is a common type shared by [SD]gemm.
|
||||
type subMul struct {
|
||||
i, j int // index of block
|
||||
}
|
||||
|
||||
func max(a, b int) int {
|
||||
if a > b {
|
||||
return a
|
||||
}
|
||||
return b
|
||||
}
|
||||
|
||||
func min(a, b int) int {
|
||||
if a > b {
|
||||
return b
|
||||
}
|
||||
return a
|
||||
}
|
||||
|
||||
// blocks returns the number of divisions of the dimension length with the given
|
||||
// block size.
|
||||
func blocks(dim, bsize int) int {
|
||||
return (dim + bsize - 1) / bsize
|
||||
}
|
||||
|
||||
// dcabs1 returns |real(z)|+|imag(z)|.
|
||||
func dcabs1(z complex128) float64 {
|
||||
return math.Abs(real(z)) + math.Abs(imag(z))
|
||||
}
|
||||
|
||||
// scabs1 returns |real(z)|+|imag(z)|.
|
||||
func scabs1(z complex64) float32 {
|
||||
return math32.Abs(real(z)) + math32.Abs(imag(z))
|
||||
}
|
||||
445
vendor/gonum.org/v1/gonum/blas/gonum/level1cmplx128.go
generated
vendored
Normal file
445
vendor/gonum.org/v1/gonum/blas/gonum/level1cmplx128.go
generated
vendored
Normal file
@@ -0,0 +1,445 @@
|
||||
// Copyright ©2017 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package gonum
|
||||
|
||||
import (
|
||||
"math"
|
||||
|
||||
"gonum.org/v1/gonum/blas"
|
||||
"gonum.org/v1/gonum/internal/asm/c128"
|
||||
)
|
||||
|
||||
var _ blas.Complex128Level1 = Implementation{}
|
||||
|
||||
// Dzasum returns the sum of the absolute values of the elements of x
|
||||
// \sum_i |Re(x[i])| + |Im(x[i])|
|
||||
// Dzasum returns 0 if incX is negative.
|
||||
func (Implementation) Dzasum(n int, x []complex128, incX int) float64 {
|
||||
if n < 0 {
|
||||
panic(nLT0)
|
||||
}
|
||||
if incX < 1 {
|
||||
if incX == 0 {
|
||||
panic(zeroIncX)
|
||||
}
|
||||
return 0
|
||||
}
|
||||
var sum float64
|
||||
if incX == 1 {
|
||||
if len(x) < n {
|
||||
panic(shortX)
|
||||
}
|
||||
for _, v := range x[:n] {
|
||||
sum += dcabs1(v)
|
||||
}
|
||||
return sum
|
||||
}
|
||||
if (n-1)*incX >= len(x) {
|
||||
panic(shortX)
|
||||
}
|
||||
for i := 0; i < n; i++ {
|
||||
v := x[i*incX]
|
||||
sum += dcabs1(v)
|
||||
}
|
||||
return sum
|
||||
}
|
||||
|
||||
// Dznrm2 computes the Euclidean norm of the complex vector x,
|
||||
// ‖x‖_2 = sqrt(\sum_i x[i] * conj(x[i])).
|
||||
// This function returns 0 if incX is negative.
|
||||
func (Implementation) Dznrm2(n int, x []complex128, incX int) float64 {
|
||||
if incX < 1 {
|
||||
if incX == 0 {
|
||||
panic(zeroIncX)
|
||||
}
|
||||
return 0
|
||||
}
|
||||
if n < 1 {
|
||||
if n == 0 {
|
||||
return 0
|
||||
}
|
||||
panic(nLT0)
|
||||
}
|
||||
if (n-1)*incX >= len(x) {
|
||||
panic(shortX)
|
||||
}
|
||||
var (
|
||||
scale float64
|
||||
ssq float64 = 1
|
||||
)
|
||||
if incX == 1 {
|
||||
for _, v := range x[:n] {
|
||||
re, im := math.Abs(real(v)), math.Abs(imag(v))
|
||||
if re != 0 {
|
||||
if re > scale {
|
||||
ssq = 1 + ssq*(scale/re)*(scale/re)
|
||||
scale = re
|
||||
} else {
|
||||
ssq += (re / scale) * (re / scale)
|
||||
}
|
||||
}
|
||||
if im != 0 {
|
||||
if im > scale {
|
||||
ssq = 1 + ssq*(scale/im)*(scale/im)
|
||||
scale = im
|
||||
} else {
|
||||
ssq += (im / scale) * (im / scale)
|
||||
}
|
||||
}
|
||||
}
|
||||
if math.IsInf(scale, 1) {
|
||||
return math.Inf(1)
|
||||
}
|
||||
return scale * math.Sqrt(ssq)
|
||||
}
|
||||
for ix := 0; ix < n*incX; ix += incX {
|
||||
re, im := math.Abs(real(x[ix])), math.Abs(imag(x[ix]))
|
||||
if re != 0 {
|
||||
if re > scale {
|
||||
ssq = 1 + ssq*(scale/re)*(scale/re)
|
||||
scale = re
|
||||
} else {
|
||||
ssq += (re / scale) * (re / scale)
|
||||
}
|
||||
}
|
||||
if im != 0 {
|
||||
if im > scale {
|
||||
ssq = 1 + ssq*(scale/im)*(scale/im)
|
||||
scale = im
|
||||
} else {
|
||||
ssq += (im / scale) * (im / scale)
|
||||
}
|
||||
}
|
||||
}
|
||||
if math.IsInf(scale, 1) {
|
||||
return math.Inf(1)
|
||||
}
|
||||
return scale * math.Sqrt(ssq)
|
||||
}
|
||||
|
||||
// Izamax returns the index of the first element of x having largest |Re(·)|+|Im(·)|.
|
||||
// Izamax returns -1 if n is 0 or incX is negative.
|
||||
func (Implementation) Izamax(n int, x []complex128, incX int) int {
|
||||
if incX < 1 {
|
||||
if incX == 0 {
|
||||
panic(zeroIncX)
|
||||
}
|
||||
// Return invalid index.
|
||||
return -1
|
||||
}
|
||||
if n < 1 {
|
||||
if n == 0 {
|
||||
// Return invalid index.
|
||||
return -1
|
||||
}
|
||||
panic(nLT0)
|
||||
}
|
||||
if len(x) <= (n-1)*incX {
|
||||
panic(shortX)
|
||||
}
|
||||
idx := 0
|
||||
max := dcabs1(x[0])
|
||||
if incX == 1 {
|
||||
for i, v := range x[1:n] {
|
||||
absV := dcabs1(v)
|
||||
if absV > max {
|
||||
max = absV
|
||||
idx = i + 1
|
||||
}
|
||||
}
|
||||
return idx
|
||||
}
|
||||
ix := incX
|
||||
for i := 1; i < n; i++ {
|
||||
absV := dcabs1(x[ix])
|
||||
if absV > max {
|
||||
max = absV
|
||||
idx = i
|
||||
}
|
||||
ix += incX
|
||||
}
|
||||
return idx
|
||||
}
|
||||
|
||||
// Zaxpy adds alpha times x to y:
|
||||
// y[i] += alpha * x[i] for all i
|
||||
func (Implementation) Zaxpy(n int, alpha complex128, x []complex128, incX int, y []complex128, incY int) {
|
||||
if incX == 0 {
|
||||
panic(zeroIncX)
|
||||
}
|
||||
if incY == 0 {
|
||||
panic(zeroIncY)
|
||||
}
|
||||
if n < 1 {
|
||||
if n == 0 {
|
||||
return
|
||||
}
|
||||
panic(nLT0)
|
||||
}
|
||||
if (incX > 0 && (n-1)*incX >= len(x)) || (incX < 0 && (1-n)*incX >= len(x)) {
|
||||
panic(shortX)
|
||||
}
|
||||
if (incY > 0 && (n-1)*incY >= len(y)) || (incY < 0 && (1-n)*incY >= len(y)) {
|
||||
panic(shortY)
|
||||
}
|
||||
if alpha == 0 {
|
||||
return
|
||||
}
|
||||
if incX == 1 && incY == 1 {
|
||||
c128.AxpyUnitary(alpha, x[:n], y[:n])
|
||||
return
|
||||
}
|
||||
var ix, iy int
|
||||
if incX < 0 {
|
||||
ix = (1 - n) * incX
|
||||
}
|
||||
if incY < 0 {
|
||||
iy = (1 - n) * incY
|
||||
}
|
||||
c128.AxpyInc(alpha, x, y, uintptr(n), uintptr(incX), uintptr(incY), uintptr(ix), uintptr(iy))
|
||||
}
|
||||
|
||||
// Zcopy copies the vector x to vector y.
|
||||
func (Implementation) Zcopy(n int, x []complex128, incX int, y []complex128, incY int) {
|
||||
if incX == 0 {
|
||||
panic(zeroIncX)
|
||||
}
|
||||
if incY == 0 {
|
||||
panic(zeroIncY)
|
||||
}
|
||||
if n < 1 {
|
||||
if n == 0 {
|
||||
return
|
||||
}
|
||||
panic(nLT0)
|
||||
}
|
||||
if (incX > 0 && (n-1)*incX >= len(x)) || (incX < 0 && (1-n)*incX >= len(x)) {
|
||||
panic(shortX)
|
||||
}
|
||||
if (incY > 0 && (n-1)*incY >= len(y)) || (incY < 0 && (1-n)*incY >= len(y)) {
|
||||
panic(shortY)
|
||||
}
|
||||
if incX == 1 && incY == 1 {
|
||||
copy(y[:n], x[:n])
|
||||
return
|
||||
}
|
||||
var ix, iy int
|
||||
if incX < 0 {
|
||||
ix = (-n + 1) * incX
|
||||
}
|
||||
if incY < 0 {
|
||||
iy = (-n + 1) * incY
|
||||
}
|
||||
for i := 0; i < n; i++ {
|
||||
y[iy] = x[ix]
|
||||
ix += incX
|
||||
iy += incY
|
||||
}
|
||||
}
|
||||
|
||||
// Zdotc computes the dot product
|
||||
// x^H · y
|
||||
// of two complex vectors x and y.
|
||||
func (Implementation) Zdotc(n int, x []complex128, incX int, y []complex128, incY int) complex128 {
|
||||
if incX == 0 {
|
||||
panic(zeroIncX)
|
||||
}
|
||||
if incY == 0 {
|
||||
panic(zeroIncY)
|
||||
}
|
||||
if n <= 0 {
|
||||
if n == 0 {
|
||||
return 0
|
||||
}
|
||||
panic(nLT0)
|
||||
}
|
||||
if incX == 1 && incY == 1 {
|
||||
if len(x) < n {
|
||||
panic(shortX)
|
||||
}
|
||||
if len(y) < n {
|
||||
panic(shortY)
|
||||
}
|
||||
return c128.DotcUnitary(x[:n], y[:n])
|
||||
}
|
||||
var ix, iy int
|
||||
if incX < 0 {
|
||||
ix = (-n + 1) * incX
|
||||
}
|
||||
if incY < 0 {
|
||||
iy = (-n + 1) * incY
|
||||
}
|
||||
if ix >= len(x) || (n-1)*incX >= len(x) {
|
||||
panic(shortX)
|
||||
}
|
||||
if iy >= len(y) || (n-1)*incY >= len(y) {
|
||||
panic(shortY)
|
||||
}
|
||||
return c128.DotcInc(x, y, uintptr(n), uintptr(incX), uintptr(incY), uintptr(ix), uintptr(iy))
|
||||
}
|
||||
|
||||
// Zdotu computes the dot product
|
||||
// x^T · y
|
||||
// of two complex vectors x and y.
|
||||
func (Implementation) Zdotu(n int, x []complex128, incX int, y []complex128, incY int) complex128 {
|
||||
if incX == 0 {
|
||||
panic(zeroIncX)
|
||||
}
|
||||
if incY == 0 {
|
||||
panic(zeroIncY)
|
||||
}
|
||||
if n <= 0 {
|
||||
if n == 0 {
|
||||
return 0
|
||||
}
|
||||
panic(nLT0)
|
||||
}
|
||||
if incX == 1 && incY == 1 {
|
||||
if len(x) < n {
|
||||
panic(shortX)
|
||||
}
|
||||
if len(y) < n {
|
||||
panic(shortY)
|
||||
}
|
||||
return c128.DotuUnitary(x[:n], y[:n])
|
||||
}
|
||||
var ix, iy int
|
||||
if incX < 0 {
|
||||
ix = (-n + 1) * incX
|
||||
}
|
||||
if incY < 0 {
|
||||
iy = (-n + 1) * incY
|
||||
}
|
||||
if ix >= len(x) || (n-1)*incX >= len(x) {
|
||||
panic(shortX)
|
||||
}
|
||||
if iy >= len(y) || (n-1)*incY >= len(y) {
|
||||
panic(shortY)
|
||||
}
|
||||
return c128.DotuInc(x, y, uintptr(n), uintptr(incX), uintptr(incY), uintptr(ix), uintptr(iy))
|
||||
}
|
||||
|
||||
// Zdscal scales the vector x by a real scalar alpha.
|
||||
// Zdscal has no effect if incX < 0.
|
||||
func (Implementation) Zdscal(n int, alpha float64, x []complex128, incX int) {
|
||||
if incX < 1 {
|
||||
if incX == 0 {
|
||||
panic(zeroIncX)
|
||||
}
|
||||
return
|
||||
}
|
||||
if (n-1)*incX >= len(x) {
|
||||
panic(shortX)
|
||||
}
|
||||
if n < 1 {
|
||||
if n == 0 {
|
||||
return
|
||||
}
|
||||
panic(nLT0)
|
||||
}
|
||||
if alpha == 0 {
|
||||
if incX == 1 {
|
||||
x = x[:n]
|
||||
for i := range x {
|
||||
x[i] = 0
|
||||
}
|
||||
return
|
||||
}
|
||||
for ix := 0; ix < n*incX; ix += incX {
|
||||
x[ix] = 0
|
||||
}
|
||||
return
|
||||
}
|
||||
if incX == 1 {
|
||||
x = x[:n]
|
||||
for i, v := range x {
|
||||
x[i] = complex(alpha*real(v), alpha*imag(v))
|
||||
}
|
||||
return
|
||||
}
|
||||
for ix := 0; ix < n*incX; ix += incX {
|
||||
v := x[ix]
|
||||
x[ix] = complex(alpha*real(v), alpha*imag(v))
|
||||
}
|
||||
}
|
||||
|
||||
// Zscal scales the vector x by a complex scalar alpha.
|
||||
// Zscal has no effect if incX < 0.
|
||||
func (Implementation) Zscal(n int, alpha complex128, x []complex128, incX int) {
|
||||
if incX < 1 {
|
||||
if incX == 0 {
|
||||
panic(zeroIncX)
|
||||
}
|
||||
return
|
||||
}
|
||||
if (n-1)*incX >= len(x) {
|
||||
panic(shortX)
|
||||
}
|
||||
if n < 1 {
|
||||
if n == 0 {
|
||||
return
|
||||
}
|
||||
panic(nLT0)
|
||||
}
|
||||
if alpha == 0 {
|
||||
if incX == 1 {
|
||||
x = x[:n]
|
||||
for i := range x {
|
||||
x[i] = 0
|
||||
}
|
||||
return
|
||||
}
|
||||
for ix := 0; ix < n*incX; ix += incX {
|
||||
x[ix] = 0
|
||||
}
|
||||
return
|
||||
}
|
||||
if incX == 1 {
|
||||
c128.ScalUnitary(alpha, x[:n])
|
||||
return
|
||||
}
|
||||
c128.ScalInc(alpha, x, uintptr(n), uintptr(incX))
|
||||
}
|
||||
|
||||
// Zswap exchanges the elements of two complex vectors x and y.
|
||||
func (Implementation) Zswap(n int, x []complex128, incX int, y []complex128, incY int) {
|
||||
if incX == 0 {
|
||||
panic(zeroIncX)
|
||||
}
|
||||
if incY == 0 {
|
||||
panic(zeroIncY)
|
||||
}
|
||||
if n < 1 {
|
||||
if n == 0 {
|
||||
return
|
||||
}
|
||||
panic(nLT0)
|
||||
}
|
||||
if (incX > 0 && (n-1)*incX >= len(x)) || (incX < 0 && (1-n)*incX >= len(x)) {
|
||||
panic(shortX)
|
||||
}
|
||||
if (incY > 0 && (n-1)*incY >= len(y)) || (incY < 0 && (1-n)*incY >= len(y)) {
|
||||
panic(shortY)
|
||||
}
|
||||
if incX == 1 && incY == 1 {
|
||||
x = x[:n]
|
||||
for i, v := range x {
|
||||
x[i], y[i] = y[i], v
|
||||
}
|
||||
return
|
||||
}
|
||||
var ix, iy int
|
||||
if incX < 0 {
|
||||
ix = (-n + 1) * incX
|
||||
}
|
||||
if incY < 0 {
|
||||
iy = (-n + 1) * incY
|
||||
}
|
||||
for i := 0; i < n; i++ {
|
||||
x[ix], y[iy] = y[iy], x[ix]
|
||||
ix += incX
|
||||
iy += incY
|
||||
}
|
||||
}
|
||||
467
vendor/gonum.org/v1/gonum/blas/gonum/level1cmplx64.go
generated
vendored
Normal file
467
vendor/gonum.org/v1/gonum/blas/gonum/level1cmplx64.go
generated
vendored
Normal file
@@ -0,0 +1,467 @@
|
||||
// Code generated by "go generate gonum.org/v1/gonum/blas/gonum”; DO NOT EDIT.
|
||||
|
||||
// Copyright ©2017 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package gonum
|
||||
|
||||
import (
|
||||
math "gonum.org/v1/gonum/internal/math32"
|
||||
|
||||
"gonum.org/v1/gonum/blas"
|
||||
"gonum.org/v1/gonum/internal/asm/c64"
|
||||
)
|
||||
|
||||
var _ blas.Complex64Level1 = Implementation{}
|
||||
|
||||
// Scasum returns the sum of the absolute values of the elements of x
|
||||
// \sum_i |Re(x[i])| + |Im(x[i])|
|
||||
// Scasum returns 0 if incX is negative.
|
||||
//
|
||||
// Complex64 implementations are autogenerated and not directly tested.
|
||||
func (Implementation) Scasum(n int, x []complex64, incX int) float32 {
|
||||
if n < 0 {
|
||||
panic(nLT0)
|
||||
}
|
||||
if incX < 1 {
|
||||
if incX == 0 {
|
||||
panic(zeroIncX)
|
||||
}
|
||||
return 0
|
||||
}
|
||||
var sum float32
|
||||
if incX == 1 {
|
||||
if len(x) < n {
|
||||
panic(shortX)
|
||||
}
|
||||
for _, v := range x[:n] {
|
||||
sum += scabs1(v)
|
||||
}
|
||||
return sum
|
||||
}
|
||||
if (n-1)*incX >= len(x) {
|
||||
panic(shortX)
|
||||
}
|
||||
for i := 0; i < n; i++ {
|
||||
v := x[i*incX]
|
||||
sum += scabs1(v)
|
||||
}
|
||||
return sum
|
||||
}
|
||||
|
||||
// Scnrm2 computes the Euclidean norm of the complex vector x,
|
||||
// ‖x‖_2 = sqrt(\sum_i x[i] * conj(x[i])).
|
||||
// This function returns 0 if incX is negative.
|
||||
//
|
||||
// Complex64 implementations are autogenerated and not directly tested.
|
||||
func (Implementation) Scnrm2(n int, x []complex64, incX int) float32 {
|
||||
if incX < 1 {
|
||||
if incX == 0 {
|
||||
panic(zeroIncX)
|
||||
}
|
||||
return 0
|
||||
}
|
||||
if n < 1 {
|
||||
if n == 0 {
|
||||
return 0
|
||||
}
|
||||
panic(nLT0)
|
||||
}
|
||||
if (n-1)*incX >= len(x) {
|
||||
panic(shortX)
|
||||
}
|
||||
var (
|
||||
scale float32
|
||||
ssq float32 = 1
|
||||
)
|
||||
if incX == 1 {
|
||||
for _, v := range x[:n] {
|
||||
re, im := math.Abs(real(v)), math.Abs(imag(v))
|
||||
if re != 0 {
|
||||
if re > scale {
|
||||
ssq = 1 + ssq*(scale/re)*(scale/re)
|
||||
scale = re
|
||||
} else {
|
||||
ssq += (re / scale) * (re / scale)
|
||||
}
|
||||
}
|
||||
if im != 0 {
|
||||
if im > scale {
|
||||
ssq = 1 + ssq*(scale/im)*(scale/im)
|
||||
scale = im
|
||||
} else {
|
||||
ssq += (im / scale) * (im / scale)
|
||||
}
|
||||
}
|
||||
}
|
||||
if math.IsInf(scale, 1) {
|
||||
return math.Inf(1)
|
||||
}
|
||||
return scale * math.Sqrt(ssq)
|
||||
}
|
||||
for ix := 0; ix < n*incX; ix += incX {
|
||||
re, im := math.Abs(real(x[ix])), math.Abs(imag(x[ix]))
|
||||
if re != 0 {
|
||||
if re > scale {
|
||||
ssq = 1 + ssq*(scale/re)*(scale/re)
|
||||
scale = re
|
||||
} else {
|
||||
ssq += (re / scale) * (re / scale)
|
||||
}
|
||||
}
|
||||
if im != 0 {
|
||||
if im > scale {
|
||||
ssq = 1 + ssq*(scale/im)*(scale/im)
|
||||
scale = im
|
||||
} else {
|
||||
ssq += (im / scale) * (im / scale)
|
||||
}
|
||||
}
|
||||
}
|
||||
if math.IsInf(scale, 1) {
|
||||
return math.Inf(1)
|
||||
}
|
||||
return scale * math.Sqrt(ssq)
|
||||
}
|
||||
|
||||
// Icamax returns the index of the first element of x having largest |Re(·)|+|Im(·)|.
|
||||
// Icamax returns -1 if n is 0 or incX is negative.
|
||||
//
|
||||
// Complex64 implementations are autogenerated and not directly tested.
|
||||
func (Implementation) Icamax(n int, x []complex64, incX int) int {
|
||||
if incX < 1 {
|
||||
if incX == 0 {
|
||||
panic(zeroIncX)
|
||||
}
|
||||
// Return invalid index.
|
||||
return -1
|
||||
}
|
||||
if n < 1 {
|
||||
if n == 0 {
|
||||
// Return invalid index.
|
||||
return -1
|
||||
}
|
||||
panic(nLT0)
|
||||
}
|
||||
if len(x) <= (n-1)*incX {
|
||||
panic(shortX)
|
||||
}
|
||||
idx := 0
|
||||
max := scabs1(x[0])
|
||||
if incX == 1 {
|
||||
for i, v := range x[1:n] {
|
||||
absV := scabs1(v)
|
||||
if absV > max {
|
||||
max = absV
|
||||
idx = i + 1
|
||||
}
|
||||
}
|
||||
return idx
|
||||
}
|
||||
ix := incX
|
||||
for i := 1; i < n; i++ {
|
||||
absV := scabs1(x[ix])
|
||||
if absV > max {
|
||||
max = absV
|
||||
idx = i
|
||||
}
|
||||
ix += incX
|
||||
}
|
||||
return idx
|
||||
}
|
||||
|
||||
// Caxpy adds alpha times x to y:
|
||||
// y[i] += alpha * x[i] for all i
|
||||
//
|
||||
// Complex64 implementations are autogenerated and not directly tested.
|
||||
func (Implementation) Caxpy(n int, alpha complex64, x []complex64, incX int, y []complex64, incY int) {
|
||||
if incX == 0 {
|
||||
panic(zeroIncX)
|
||||
}
|
||||
if incY == 0 {
|
||||
panic(zeroIncY)
|
||||
}
|
||||
if n < 1 {
|
||||
if n == 0 {
|
||||
return
|
||||
}
|
||||
panic(nLT0)
|
||||
}
|
||||
if (incX > 0 && (n-1)*incX >= len(x)) || (incX < 0 && (1-n)*incX >= len(x)) {
|
||||
panic(shortX)
|
||||
}
|
||||
if (incY > 0 && (n-1)*incY >= len(y)) || (incY < 0 && (1-n)*incY >= len(y)) {
|
||||
panic(shortY)
|
||||
}
|
||||
if alpha == 0 {
|
||||
return
|
||||
}
|
||||
if incX == 1 && incY == 1 {
|
||||
c64.AxpyUnitary(alpha, x[:n], y[:n])
|
||||
return
|
||||
}
|
||||
var ix, iy int
|
||||
if incX < 0 {
|
||||
ix = (1 - n) * incX
|
||||
}
|
||||
if incY < 0 {
|
||||
iy = (1 - n) * incY
|
||||
}
|
||||
c64.AxpyInc(alpha, x, y, uintptr(n), uintptr(incX), uintptr(incY), uintptr(ix), uintptr(iy))
|
||||
}
|
||||
|
||||
// Ccopy copies the vector x to vector y.
|
||||
//
|
||||
// Complex64 implementations are autogenerated and not directly tested.
|
||||
func (Implementation) Ccopy(n int, x []complex64, incX int, y []complex64, incY int) {
|
||||
if incX == 0 {
|
||||
panic(zeroIncX)
|
||||
}
|
||||
if incY == 0 {
|
||||
panic(zeroIncY)
|
||||
}
|
||||
if n < 1 {
|
||||
if n == 0 {
|
||||
return
|
||||
}
|
||||
panic(nLT0)
|
||||
}
|
||||
if (incX > 0 && (n-1)*incX >= len(x)) || (incX < 0 && (1-n)*incX >= len(x)) {
|
||||
panic(shortX)
|
||||
}
|
||||
if (incY > 0 && (n-1)*incY >= len(y)) || (incY < 0 && (1-n)*incY >= len(y)) {
|
||||
panic(shortY)
|
||||
}
|
||||
if incX == 1 && incY == 1 {
|
||||
copy(y[:n], x[:n])
|
||||
return
|
||||
}
|
||||
var ix, iy int
|
||||
if incX < 0 {
|
||||
ix = (-n + 1) * incX
|
||||
}
|
||||
if incY < 0 {
|
||||
iy = (-n + 1) * incY
|
||||
}
|
||||
for i := 0; i < n; i++ {
|
||||
y[iy] = x[ix]
|
||||
ix += incX
|
||||
iy += incY
|
||||
}
|
||||
}
|
||||
|
||||
// Cdotc computes the dot product
|
||||
// x^H · y
|
||||
// of two complex vectors x and y.
|
||||
//
|
||||
// Complex64 implementations are autogenerated and not directly tested.
|
||||
func (Implementation) Cdotc(n int, x []complex64, incX int, y []complex64, incY int) complex64 {
|
||||
if incX == 0 {
|
||||
panic(zeroIncX)
|
||||
}
|
||||
if incY == 0 {
|
||||
panic(zeroIncY)
|
||||
}
|
||||
if n <= 0 {
|
||||
if n == 0 {
|
||||
return 0
|
||||
}
|
||||
panic(nLT0)
|
||||
}
|
||||
if incX == 1 && incY == 1 {
|
||||
if len(x) < n {
|
||||
panic(shortX)
|
||||
}
|
||||
if len(y) < n {
|
||||
panic(shortY)
|
||||
}
|
||||
return c64.DotcUnitary(x[:n], y[:n])
|
||||
}
|
||||
var ix, iy int
|
||||
if incX < 0 {
|
||||
ix = (-n + 1) * incX
|
||||
}
|
||||
if incY < 0 {
|
||||
iy = (-n + 1) * incY
|
||||
}
|
||||
if ix >= len(x) || (n-1)*incX >= len(x) {
|
||||
panic(shortX)
|
||||
}
|
||||
if iy >= len(y) || (n-1)*incY >= len(y) {
|
||||
panic(shortY)
|
||||
}
|
||||
return c64.DotcInc(x, y, uintptr(n), uintptr(incX), uintptr(incY), uintptr(ix), uintptr(iy))
|
||||
}
|
||||
|
||||
// Cdotu computes the dot product
|
||||
// x^T · y
|
||||
// of two complex vectors x and y.
|
||||
//
|
||||
// Complex64 implementations are autogenerated and not directly tested.
|
||||
func (Implementation) Cdotu(n int, x []complex64, incX int, y []complex64, incY int) complex64 {
|
||||
if incX == 0 {
|
||||
panic(zeroIncX)
|
||||
}
|
||||
if incY == 0 {
|
||||
panic(zeroIncY)
|
||||
}
|
||||
if n <= 0 {
|
||||
if n == 0 {
|
||||
return 0
|
||||
}
|
||||
panic(nLT0)
|
||||
}
|
||||
if incX == 1 && incY == 1 {
|
||||
if len(x) < n {
|
||||
panic(shortX)
|
||||
}
|
||||
if len(y) < n {
|
||||
panic(shortY)
|
||||
}
|
||||
return c64.DotuUnitary(x[:n], y[:n])
|
||||
}
|
||||
var ix, iy int
|
||||
if incX < 0 {
|
||||
ix = (-n + 1) * incX
|
||||
}
|
||||
if incY < 0 {
|
||||
iy = (-n + 1) * incY
|
||||
}
|
||||
if ix >= len(x) || (n-1)*incX >= len(x) {
|
||||
panic(shortX)
|
||||
}
|
||||
if iy >= len(y) || (n-1)*incY >= len(y) {
|
||||
panic(shortY)
|
||||
}
|
||||
return c64.DotuInc(x, y, uintptr(n), uintptr(incX), uintptr(incY), uintptr(ix), uintptr(iy))
|
||||
}
|
||||
|
||||
// Csscal scales the vector x by a real scalar alpha.
|
||||
// Csscal has no effect if incX < 0.
|
||||
//
|
||||
// Complex64 implementations are autogenerated and not directly tested.
|
||||
func (Implementation) Csscal(n int, alpha float32, x []complex64, incX int) {
|
||||
if incX < 1 {
|
||||
if incX == 0 {
|
||||
panic(zeroIncX)
|
||||
}
|
||||
return
|
||||
}
|
||||
if (n-1)*incX >= len(x) {
|
||||
panic(shortX)
|
||||
}
|
||||
if n < 1 {
|
||||
if n == 0 {
|
||||
return
|
||||
}
|
||||
panic(nLT0)
|
||||
}
|
||||
if alpha == 0 {
|
||||
if incX == 1 {
|
||||
x = x[:n]
|
||||
for i := range x {
|
||||
x[i] = 0
|
||||
}
|
||||
return
|
||||
}
|
||||
for ix := 0; ix < n*incX; ix += incX {
|
||||
x[ix] = 0
|
||||
}
|
||||
return
|
||||
}
|
||||
if incX == 1 {
|
||||
x = x[:n]
|
||||
for i, v := range x {
|
||||
x[i] = complex(alpha*real(v), alpha*imag(v))
|
||||
}
|
||||
return
|
||||
}
|
||||
for ix := 0; ix < n*incX; ix += incX {
|
||||
v := x[ix]
|
||||
x[ix] = complex(alpha*real(v), alpha*imag(v))
|
||||
}
|
||||
}
|
||||
|
||||
// Cscal scales the vector x by a complex scalar alpha.
|
||||
// Cscal has no effect if incX < 0.
|
||||
//
|
||||
// Complex64 implementations are autogenerated and not directly tested.
|
||||
func (Implementation) Cscal(n int, alpha complex64, x []complex64, incX int) {
|
||||
if incX < 1 {
|
||||
if incX == 0 {
|
||||
panic(zeroIncX)
|
||||
}
|
||||
return
|
||||
}
|
||||
if (n-1)*incX >= len(x) {
|
||||
panic(shortX)
|
||||
}
|
||||
if n < 1 {
|
||||
if n == 0 {
|
||||
return
|
||||
}
|
||||
panic(nLT0)
|
||||
}
|
||||
if alpha == 0 {
|
||||
if incX == 1 {
|
||||
x = x[:n]
|
||||
for i := range x {
|
||||
x[i] = 0
|
||||
}
|
||||
return
|
||||
}
|
||||
for ix := 0; ix < n*incX; ix += incX {
|
||||
x[ix] = 0
|
||||
}
|
||||
return
|
||||
}
|
||||
if incX == 1 {
|
||||
c64.ScalUnitary(alpha, x[:n])
|
||||
return
|
||||
}
|
||||
c64.ScalInc(alpha, x, uintptr(n), uintptr(incX))
|
||||
}
|
||||
|
||||
// Cswap exchanges the elements of two complex vectors x and y.
|
||||
//
|
||||
// Complex64 implementations are autogenerated and not directly tested.
|
||||
func (Implementation) Cswap(n int, x []complex64, incX int, y []complex64, incY int) {
|
||||
if incX == 0 {
|
||||
panic(zeroIncX)
|
||||
}
|
||||
if incY == 0 {
|
||||
panic(zeroIncY)
|
||||
}
|
||||
if n < 1 {
|
||||
if n == 0 {
|
||||
return
|
||||
}
|
||||
panic(nLT0)
|
||||
}
|
||||
if (incX > 0 && (n-1)*incX >= len(x)) || (incX < 0 && (1-n)*incX >= len(x)) {
|
||||
panic(shortX)
|
||||
}
|
||||
if (incY > 0 && (n-1)*incY >= len(y)) || (incY < 0 && (1-n)*incY >= len(y)) {
|
||||
panic(shortY)
|
||||
}
|
||||
if incX == 1 && incY == 1 {
|
||||
x = x[:n]
|
||||
for i, v := range x {
|
||||
x[i], y[i] = y[i], v
|
||||
}
|
||||
return
|
||||
}
|
||||
var ix, iy int
|
||||
if incX < 0 {
|
||||
ix = (-n + 1) * incX
|
||||
}
|
||||
if incY < 0 {
|
||||
iy = (-n + 1) * incY
|
||||
}
|
||||
for i := 0; i < n; i++ {
|
||||
x[ix], y[iy] = y[iy], x[ix]
|
||||
ix += incX
|
||||
iy += incY
|
||||
}
|
||||
}
|
||||
644
vendor/gonum.org/v1/gonum/blas/gonum/level1float32.go
generated
vendored
Normal file
644
vendor/gonum.org/v1/gonum/blas/gonum/level1float32.go
generated
vendored
Normal file
@@ -0,0 +1,644 @@
|
||||
// Code generated by "go generate gonum.org/v1/gonum/blas/gonum”; DO NOT EDIT.
|
||||
|
||||
// Copyright ©2015 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package gonum
|
||||
|
||||
import (
|
||||
math "gonum.org/v1/gonum/internal/math32"
|
||||
|
||||
"gonum.org/v1/gonum/blas"
|
||||
"gonum.org/v1/gonum/internal/asm/f32"
|
||||
)
|
||||
|
||||
var _ blas.Float32Level1 = Implementation{}
|
||||
|
||||
// Snrm2 computes the Euclidean norm of a vector,
|
||||
// sqrt(\sum_i x[i] * x[i]).
|
||||
// This function returns 0 if incX is negative.
|
||||
//
|
||||
// Float32 implementations are autogenerated and not directly tested.
|
||||
func (Implementation) Snrm2(n int, x []float32, incX int) float32 {
|
||||
if incX < 1 {
|
||||
if incX == 0 {
|
||||
panic(zeroIncX)
|
||||
}
|
||||
return 0
|
||||
}
|
||||
if len(x) <= (n-1)*incX {
|
||||
panic(shortX)
|
||||
}
|
||||
if n < 2 {
|
||||
if n == 1 {
|
||||
return math.Abs(x[0])
|
||||
}
|
||||
if n == 0 {
|
||||
return 0
|
||||
}
|
||||
panic(nLT0)
|
||||
}
|
||||
var (
|
||||
scale float32 = 0
|
||||
sumSquares float32 = 1
|
||||
)
|
||||
if incX == 1 {
|
||||
x = x[:n]
|
||||
for _, v := range x {
|
||||
if v == 0 {
|
||||
continue
|
||||
}
|
||||
absxi := math.Abs(v)
|
||||
if math.IsNaN(absxi) {
|
||||
return math.NaN()
|
||||
}
|
||||
if scale < absxi {
|
||||
sumSquares = 1 + sumSquares*(scale/absxi)*(scale/absxi)
|
||||
scale = absxi
|
||||
} else {
|
||||
sumSquares = sumSquares + (absxi/scale)*(absxi/scale)
|
||||
}
|
||||
}
|
||||
if math.IsInf(scale, 1) {
|
||||
return math.Inf(1)
|
||||
}
|
||||
return scale * math.Sqrt(sumSquares)
|
||||
}
|
||||
for ix := 0; ix < n*incX; ix += incX {
|
||||
val := x[ix]
|
||||
if val == 0 {
|
||||
continue
|
||||
}
|
||||
absxi := math.Abs(val)
|
||||
if math.IsNaN(absxi) {
|
||||
return math.NaN()
|
||||
}
|
||||
if scale < absxi {
|
||||
sumSquares = 1 + sumSquares*(scale/absxi)*(scale/absxi)
|
||||
scale = absxi
|
||||
} else {
|
||||
sumSquares = sumSquares + (absxi/scale)*(absxi/scale)
|
||||
}
|
||||
}
|
||||
if math.IsInf(scale, 1) {
|
||||
return math.Inf(1)
|
||||
}
|
||||
return scale * math.Sqrt(sumSquares)
|
||||
}
|
||||
|
||||
// Sasum computes the sum of the absolute values of the elements of x.
|
||||
// \sum_i |x[i]|
|
||||
// Sasum returns 0 if incX is negative.
|
||||
//
|
||||
// Float32 implementations are autogenerated and not directly tested.
|
||||
func (Implementation) Sasum(n int, x []float32, incX int) float32 {
|
||||
var sum float32
|
||||
if n < 0 {
|
||||
panic(nLT0)
|
||||
}
|
||||
if incX < 1 {
|
||||
if incX == 0 {
|
||||
panic(zeroIncX)
|
||||
}
|
||||
return 0
|
||||
}
|
||||
if len(x) <= (n-1)*incX {
|
||||
panic(shortX)
|
||||
}
|
||||
if incX == 1 {
|
||||
x = x[:n]
|
||||
for _, v := range x {
|
||||
sum += math.Abs(v)
|
||||
}
|
||||
return sum
|
||||
}
|
||||
for i := 0; i < n; i++ {
|
||||
sum += math.Abs(x[i*incX])
|
||||
}
|
||||
return sum
|
||||
}
|
||||
|
||||
// Isamax returns the index of an element of x with the largest absolute value.
|
||||
// If there are multiple such indices the earliest is returned.
|
||||
// Isamax returns -1 if n == 0.
|
||||
//
|
||||
// Float32 implementations are autogenerated and not directly tested.
|
||||
func (Implementation) Isamax(n int, x []float32, incX int) int {
|
||||
if incX < 1 {
|
||||
if incX == 0 {
|
||||
panic(zeroIncX)
|
||||
}
|
||||
return -1
|
||||
}
|
||||
if len(x) <= (n-1)*incX {
|
||||
panic(shortX)
|
||||
}
|
||||
if n < 2 {
|
||||
if n == 1 {
|
||||
return 0
|
||||
}
|
||||
if n == 0 {
|
||||
return -1 // Netlib returns invalid index when n == 0.
|
||||
}
|
||||
panic(nLT0)
|
||||
}
|
||||
idx := 0
|
||||
max := math.Abs(x[0])
|
||||
if incX == 1 {
|
||||
for i, v := range x[:n] {
|
||||
absV := math.Abs(v)
|
||||
if absV > max {
|
||||
max = absV
|
||||
idx = i
|
||||
}
|
||||
}
|
||||
return idx
|
||||
}
|
||||
ix := incX
|
||||
for i := 1; i < n; i++ {
|
||||
v := x[ix]
|
||||
absV := math.Abs(v)
|
||||
if absV > max {
|
||||
max = absV
|
||||
idx = i
|
||||
}
|
||||
ix += incX
|
||||
}
|
||||
return idx
|
||||
}
|
||||
|
||||
// Sswap exchanges the elements of two vectors.
|
||||
// x[i], y[i] = y[i], x[i] for all i
|
||||
//
|
||||
// Float32 implementations are autogenerated and not directly tested.
|
||||
func (Implementation) Sswap(n int, x []float32, incX int, y []float32, incY int) {
|
||||
if incX == 0 {
|
||||
panic(zeroIncX)
|
||||
}
|
||||
if incY == 0 {
|
||||
panic(zeroIncY)
|
||||
}
|
||||
if n < 1 {
|
||||
if n == 0 {
|
||||
return
|
||||
}
|
||||
panic(nLT0)
|
||||
}
|
||||
if (incX > 0 && len(x) <= (n-1)*incX) || (incX < 0 && len(x) <= (1-n)*incX) {
|
||||
panic(shortX)
|
||||
}
|
||||
if (incY > 0 && len(y) <= (n-1)*incY) || (incY < 0 && len(y) <= (1-n)*incY) {
|
||||
panic(shortY)
|
||||
}
|
||||
if incX == 1 && incY == 1 {
|
||||
x = x[:n]
|
||||
for i, v := range x {
|
||||
x[i], y[i] = y[i], v
|
||||
}
|
||||
return
|
||||
}
|
||||
var ix, iy int
|
||||
if incX < 0 {
|
||||
ix = (-n + 1) * incX
|
||||
}
|
||||
if incY < 0 {
|
||||
iy = (-n + 1) * incY
|
||||
}
|
||||
for i := 0; i < n; i++ {
|
||||
x[ix], y[iy] = y[iy], x[ix]
|
||||
ix += incX
|
||||
iy += incY
|
||||
}
|
||||
}
|
||||
|
||||
// Scopy copies the elements of x into the elements of y.
|
||||
// y[i] = x[i] for all i
|
||||
//
|
||||
// Float32 implementations are autogenerated and not directly tested.
|
||||
func (Implementation) Scopy(n int, x []float32, incX int, y []float32, incY int) {
|
||||
if incX == 0 {
|
||||
panic(zeroIncX)
|
||||
}
|
||||
if incY == 0 {
|
||||
panic(zeroIncY)
|
||||
}
|
||||
if n < 1 {
|
||||
if n == 0 {
|
||||
return
|
||||
}
|
||||
panic(nLT0)
|
||||
}
|
||||
if (incX > 0 && len(x) <= (n-1)*incX) || (incX < 0 && len(x) <= (1-n)*incX) {
|
||||
panic(shortX)
|
||||
}
|
||||
if (incY > 0 && len(y) <= (n-1)*incY) || (incY < 0 && len(y) <= (1-n)*incY) {
|
||||
panic(shortY)
|
||||
}
|
||||
if incX == 1 && incY == 1 {
|
||||
copy(y[:n], x[:n])
|
||||
return
|
||||
}
|
||||
var ix, iy int
|
||||
if incX < 0 {
|
||||
ix = (-n + 1) * incX
|
||||
}
|
||||
if incY < 0 {
|
||||
iy = (-n + 1) * incY
|
||||
}
|
||||
for i := 0; i < n; i++ {
|
||||
y[iy] = x[ix]
|
||||
ix += incX
|
||||
iy += incY
|
||||
}
|
||||
}
|
||||
|
||||
// Saxpy adds alpha times x to y
|
||||
// y[i] += alpha * x[i] for all i
|
||||
//
|
||||
// Float32 implementations are autogenerated and not directly tested.
|
||||
func (Implementation) Saxpy(n int, alpha float32, x []float32, incX int, y []float32, incY int) {
|
||||
if incX == 0 {
|
||||
panic(zeroIncX)
|
||||
}
|
||||
if incY == 0 {
|
||||
panic(zeroIncY)
|
||||
}
|
||||
if n < 1 {
|
||||
if n == 0 {
|
||||
return
|
||||
}
|
||||
panic(nLT0)
|
||||
}
|
||||
if (incX > 0 && len(x) <= (n-1)*incX) || (incX < 0 && len(x) <= (1-n)*incX) {
|
||||
panic(shortX)
|
||||
}
|
||||
if (incY > 0 && len(y) <= (n-1)*incY) || (incY < 0 && len(y) <= (1-n)*incY) {
|
||||
panic(shortY)
|
||||
}
|
||||
if alpha == 0 {
|
||||
return
|
||||
}
|
||||
if incX == 1 && incY == 1 {
|
||||
f32.AxpyUnitary(alpha, x[:n], y[:n])
|
||||
return
|
||||
}
|
||||
var ix, iy int
|
||||
if incX < 0 {
|
||||
ix = (-n + 1) * incX
|
||||
}
|
||||
if incY < 0 {
|
||||
iy = (-n + 1) * incY
|
||||
}
|
||||
f32.AxpyInc(alpha, x, y, uintptr(n), uintptr(incX), uintptr(incY), uintptr(ix), uintptr(iy))
|
||||
}
|
||||
|
||||
// Srotg computes the plane rotation
|
||||
// _ _ _ _ _ _
|
||||
// | c s | | a | | r |
|
||||
// | -s c | * | b | = | 0 |
|
||||
// ‾ ‾ ‾ ‾ ‾ ‾
|
||||
// where
|
||||
// r = ±√(a^2 + b^2)
|
||||
// c = a/r, the cosine of the plane rotation
|
||||
// s = b/r, the sine of the plane rotation
|
||||
//
|
||||
// NOTE: There is a discrepancy between the reference implementation and the BLAS
|
||||
// technical manual regarding the sign for r when a or b are zero.
|
||||
// Srotg agrees with the definition in the manual and other
|
||||
// common BLAS implementations.
|
||||
//
|
||||
// Float32 implementations are autogenerated and not directly tested.
|
||||
func (Implementation) Srotg(a, b float32) (c, s, r, z float32) {
|
||||
if b == 0 && a == 0 {
|
||||
return 1, 0, a, 0
|
||||
}
|
||||
absA := math.Abs(a)
|
||||
absB := math.Abs(b)
|
||||
aGTb := absA > absB
|
||||
r = math.Hypot(a, b)
|
||||
if aGTb {
|
||||
r = math.Copysign(r, a)
|
||||
} else {
|
||||
r = math.Copysign(r, b)
|
||||
}
|
||||
c = a / r
|
||||
s = b / r
|
||||
if aGTb {
|
||||
z = s
|
||||
} else if c != 0 { // r == 0 case handled above
|
||||
z = 1 / c
|
||||
} else {
|
||||
z = 1
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// Srotmg computes the modified Givens rotation. See
|
||||
// http://www.netlib.org/lapack/explore-html/df/deb/drotmg_8f.html
|
||||
// for more details.
|
||||
//
|
||||
// Float32 implementations are autogenerated and not directly tested.
|
||||
func (Implementation) Srotmg(d1, d2, x1, y1 float32) (p blas.SrotmParams, rd1, rd2, rx1 float32) {
|
||||
// The implementation of Drotmg used here is taken from Hopkins 1997
|
||||
// Appendix A: https://doi.org/10.1145/289251.289253
|
||||
// with the exception of the gam constants below.
|
||||
|
||||
const (
|
||||
gam = 4096.0
|
||||
gamsq = gam * gam
|
||||
rgamsq = 1.0 / gamsq
|
||||
)
|
||||
|
||||
if d1 < 0 {
|
||||
p.Flag = blas.Rescaling // Error state.
|
||||
return p, 0, 0, 0
|
||||
}
|
||||
|
||||
if d2 == 0 || y1 == 0 {
|
||||
p.Flag = blas.Identity
|
||||
return p, d1, d2, x1
|
||||
}
|
||||
|
||||
var h11, h12, h21, h22 float32
|
||||
if (d1 == 0 || x1 == 0) && d2 > 0 {
|
||||
p.Flag = blas.Diagonal
|
||||
h12 = 1
|
||||
h21 = -1
|
||||
x1 = y1
|
||||
d1, d2 = d2, d1
|
||||
} else {
|
||||
p2 := d2 * y1
|
||||
p1 := d1 * x1
|
||||
q2 := p2 * y1
|
||||
q1 := p1 * x1
|
||||
if math.Abs(q1) > math.Abs(q2) {
|
||||
p.Flag = blas.OffDiagonal
|
||||
h11 = 1
|
||||
h22 = 1
|
||||
h21 = -y1 / x1
|
||||
h12 = p2 / p1
|
||||
u := 1 - h12*h21
|
||||
if u <= 0 {
|
||||
p.Flag = blas.Rescaling // Error state.
|
||||
return p, 0, 0, 0
|
||||
}
|
||||
|
||||
d1 /= u
|
||||
d2 /= u
|
||||
x1 *= u
|
||||
} else {
|
||||
if q2 < 0 {
|
||||
p.Flag = blas.Rescaling // Error state.
|
||||
return p, 0, 0, 0
|
||||
}
|
||||
|
||||
p.Flag = blas.Diagonal
|
||||
h21 = -1
|
||||
h12 = 1
|
||||
h11 = p1 / p2
|
||||
h22 = x1 / y1
|
||||
u := 1 + h11*h22
|
||||
d1, d2 = d2/u, d1/u
|
||||
x1 = y1 * u
|
||||
}
|
||||
}
|
||||
|
||||
for d1 <= rgamsq && d1 != 0 {
|
||||
p.Flag = blas.Rescaling
|
||||
d1 = (d1 * gam) * gam
|
||||
x1 /= gam
|
||||
h11 /= gam
|
||||
h12 /= gam
|
||||
}
|
||||
for d1 > gamsq {
|
||||
p.Flag = blas.Rescaling
|
||||
d1 = (d1 / gam) / gam
|
||||
x1 *= gam
|
||||
h11 *= gam
|
||||
h12 *= gam
|
||||
}
|
||||
|
||||
for math.Abs(d2) <= rgamsq && d2 != 0 {
|
||||
p.Flag = blas.Rescaling
|
||||
d2 = (d2 * gam) * gam
|
||||
h21 /= gam
|
||||
h22 /= gam
|
||||
}
|
||||
for math.Abs(d2) > gamsq {
|
||||
p.Flag = blas.Rescaling
|
||||
d2 = (d2 / gam) / gam
|
||||
h21 *= gam
|
||||
h22 *= gam
|
||||
}
|
||||
|
||||
switch p.Flag {
|
||||
case blas.Diagonal:
|
||||
p.H = [4]float32{0: h11, 3: h22}
|
||||
case blas.OffDiagonal:
|
||||
p.H = [4]float32{1: h21, 2: h12}
|
||||
case blas.Rescaling:
|
||||
p.H = [4]float32{h11, h21, h12, h22}
|
||||
default:
|
||||
panic(badFlag)
|
||||
}
|
||||
|
||||
return p, d1, d2, x1
|
||||
}
|
||||
|
||||
// Srot applies a plane transformation.
|
||||
// x[i] = c * x[i] + s * y[i]
|
||||
// y[i] = c * y[i] - s * x[i]
|
||||
//
|
||||
// Float32 implementations are autogenerated and not directly tested.
|
||||
func (Implementation) Srot(n int, x []float32, incX int, y []float32, incY int, c float32, s float32) {
|
||||
if incX == 0 {
|
||||
panic(zeroIncX)
|
||||
}
|
||||
if incY == 0 {
|
||||
panic(zeroIncY)
|
||||
}
|
||||
if n < 1 {
|
||||
if n == 0 {
|
||||
return
|
||||
}
|
||||
panic(nLT0)
|
||||
}
|
||||
if (incX > 0 && len(x) <= (n-1)*incX) || (incX < 0 && len(x) <= (1-n)*incX) {
|
||||
panic(shortX)
|
||||
}
|
||||
if (incY > 0 && len(y) <= (n-1)*incY) || (incY < 0 && len(y) <= (1-n)*incY) {
|
||||
panic(shortY)
|
||||
}
|
||||
if incX == 1 && incY == 1 {
|
||||
x = x[:n]
|
||||
for i, vx := range x {
|
||||
vy := y[i]
|
||||
x[i], y[i] = c*vx+s*vy, c*vy-s*vx
|
||||
}
|
||||
return
|
||||
}
|
||||
var ix, iy int
|
||||
if incX < 0 {
|
||||
ix = (-n + 1) * incX
|
||||
}
|
||||
if incY < 0 {
|
||||
iy = (-n + 1) * incY
|
||||
}
|
||||
for i := 0; i < n; i++ {
|
||||
vx := x[ix]
|
||||
vy := y[iy]
|
||||
x[ix], y[iy] = c*vx+s*vy, c*vy-s*vx
|
||||
ix += incX
|
||||
iy += incY
|
||||
}
|
||||
}
|
||||
|
||||
// Srotm applies the modified Givens rotation to the 2×n matrix.
|
||||
//
|
||||
// Float32 implementations are autogenerated and not directly tested.
|
||||
func (Implementation) Srotm(n int, x []float32, incX int, y []float32, incY int, p blas.SrotmParams) {
|
||||
if incX == 0 {
|
||||
panic(zeroIncX)
|
||||
}
|
||||
if incY == 0 {
|
||||
panic(zeroIncY)
|
||||
}
|
||||
if n <= 0 {
|
||||
if n == 0 {
|
||||
return
|
||||
}
|
||||
panic(nLT0)
|
||||
}
|
||||
if (incX > 0 && len(x) <= (n-1)*incX) || (incX < 0 && len(x) <= (1-n)*incX) {
|
||||
panic(shortX)
|
||||
}
|
||||
if (incY > 0 && len(y) <= (n-1)*incY) || (incY < 0 && len(y) <= (1-n)*incY) {
|
||||
panic(shortY)
|
||||
}
|
||||
|
||||
if p.Flag == blas.Identity {
|
||||
return
|
||||
}
|
||||
|
||||
switch p.Flag {
|
||||
case blas.Rescaling:
|
||||
h11 := p.H[0]
|
||||
h12 := p.H[2]
|
||||
h21 := p.H[1]
|
||||
h22 := p.H[3]
|
||||
if incX == 1 && incY == 1 {
|
||||
x = x[:n]
|
||||
for i, vx := range x {
|
||||
vy := y[i]
|
||||
x[i], y[i] = vx*h11+vy*h12, vx*h21+vy*h22
|
||||
}
|
||||
return
|
||||
}
|
||||
var ix, iy int
|
||||
if incX < 0 {
|
||||
ix = (-n + 1) * incX
|
||||
}
|
||||
if incY < 0 {
|
||||
iy = (-n + 1) * incY
|
||||
}
|
||||
for i := 0; i < n; i++ {
|
||||
vx := x[ix]
|
||||
vy := y[iy]
|
||||
x[ix], y[iy] = vx*h11+vy*h12, vx*h21+vy*h22
|
||||
ix += incX
|
||||
iy += incY
|
||||
}
|
||||
case blas.OffDiagonal:
|
||||
h12 := p.H[2]
|
||||
h21 := p.H[1]
|
||||
if incX == 1 && incY == 1 {
|
||||
x = x[:n]
|
||||
for i, vx := range x {
|
||||
vy := y[i]
|
||||
x[i], y[i] = vx+vy*h12, vx*h21+vy
|
||||
}
|
||||
return
|
||||
}
|
||||
var ix, iy int
|
||||
if incX < 0 {
|
||||
ix = (-n + 1) * incX
|
||||
}
|
||||
if incY < 0 {
|
||||
iy = (-n + 1) * incY
|
||||
}
|
||||
for i := 0; i < n; i++ {
|
||||
vx := x[ix]
|
||||
vy := y[iy]
|
||||
x[ix], y[iy] = vx+vy*h12, vx*h21+vy
|
||||
ix += incX
|
||||
iy += incY
|
||||
}
|
||||
case blas.Diagonal:
|
||||
h11 := p.H[0]
|
||||
h22 := p.H[3]
|
||||
if incX == 1 && incY == 1 {
|
||||
x = x[:n]
|
||||
for i, vx := range x {
|
||||
vy := y[i]
|
||||
x[i], y[i] = vx*h11+vy, -vx+vy*h22
|
||||
}
|
||||
return
|
||||
}
|
||||
var ix, iy int
|
||||
if incX < 0 {
|
||||
ix = (-n + 1) * incX
|
||||
}
|
||||
if incY < 0 {
|
||||
iy = (-n + 1) * incY
|
||||
}
|
||||
for i := 0; i < n; i++ {
|
||||
vx := x[ix]
|
||||
vy := y[iy]
|
||||
x[ix], y[iy] = vx*h11+vy, -vx+vy*h22
|
||||
ix += incX
|
||||
iy += incY
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Sscal scales x by alpha.
|
||||
// x[i] *= alpha
|
||||
// Sscal has no effect if incX < 0.
|
||||
//
|
||||
// Float32 implementations are autogenerated and not directly tested.
|
||||
func (Implementation) Sscal(n int, alpha float32, x []float32, incX int) {
|
||||
if incX < 1 {
|
||||
if incX == 0 {
|
||||
panic(zeroIncX)
|
||||
}
|
||||
return
|
||||
}
|
||||
if n < 1 {
|
||||
if n == 0 {
|
||||
return
|
||||
}
|
||||
panic(nLT0)
|
||||
}
|
||||
if (n-1)*incX >= len(x) {
|
||||
panic(shortX)
|
||||
}
|
||||
if alpha == 0 {
|
||||
if incX == 1 {
|
||||
x = x[:n]
|
||||
for i := range x {
|
||||
x[i] = 0
|
||||
}
|
||||
return
|
||||
}
|
||||
for ix := 0; ix < n*incX; ix += incX {
|
||||
x[ix] = 0
|
||||
}
|
||||
return
|
||||
}
|
||||
if incX == 1 {
|
||||
f32.ScalUnitary(alpha, x[:n])
|
||||
return
|
||||
}
|
||||
f32.ScalInc(alpha, x, uintptr(n), uintptr(incX))
|
||||
}
|
||||
53
vendor/gonum.org/v1/gonum/blas/gonum/level1float32_dsdot.go
generated
vendored
Normal file
53
vendor/gonum.org/v1/gonum/blas/gonum/level1float32_dsdot.go
generated
vendored
Normal file
@@ -0,0 +1,53 @@
|
||||
// Code generated by "go generate gonum.org/v1/gonum/blas/gonum”; DO NOT EDIT.
|
||||
|
||||
// Copyright ©2015 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package gonum
|
||||
|
||||
import (
|
||||
"gonum.org/v1/gonum/internal/asm/f32"
|
||||
)
|
||||
|
||||
// Dsdot computes the dot product of the two vectors
|
||||
// \sum_i x[i]*y[i]
|
||||
//
|
||||
// Float32 implementations are autogenerated and not directly tested.
|
||||
func (Implementation) Dsdot(n int, x []float32, incX int, y []float32, incY int) float64 {
|
||||
if incX == 0 {
|
||||
panic(zeroIncX)
|
||||
}
|
||||
if incY == 0 {
|
||||
panic(zeroIncY)
|
||||
}
|
||||
if n <= 0 {
|
||||
if n == 0 {
|
||||
return 0
|
||||
}
|
||||
panic(nLT0)
|
||||
}
|
||||
if incX == 1 && incY == 1 {
|
||||
if len(x) < n {
|
||||
panic(shortX)
|
||||
}
|
||||
if len(y) < n {
|
||||
panic(shortY)
|
||||
}
|
||||
return f32.DdotUnitary(x[:n], y[:n])
|
||||
}
|
||||
var ix, iy int
|
||||
if incX < 0 {
|
||||
ix = (-n + 1) * incX
|
||||
}
|
||||
if incY < 0 {
|
||||
iy = (-n + 1) * incY
|
||||
}
|
||||
if ix >= len(x) || ix+(n-1)*incX >= len(x) {
|
||||
panic(shortX)
|
||||
}
|
||||
if iy >= len(y) || iy+(n-1)*incY >= len(y) {
|
||||
panic(shortY)
|
||||
}
|
||||
return f32.DdotInc(x, y, uintptr(n), uintptr(incX), uintptr(incY), uintptr(ix), uintptr(iy))
|
||||
}
|
||||
53
vendor/gonum.org/v1/gonum/blas/gonum/level1float32_sdot.go
generated
vendored
Normal file
53
vendor/gonum.org/v1/gonum/blas/gonum/level1float32_sdot.go
generated
vendored
Normal file
@@ -0,0 +1,53 @@
|
||||
// Code generated by "go generate gonum.org/v1/gonum/blas/gonum”; DO NOT EDIT.
|
||||
|
||||
// Copyright ©2015 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package gonum
|
||||
|
||||
import (
|
||||
"gonum.org/v1/gonum/internal/asm/f32"
|
||||
)
|
||||
|
||||
// Sdot computes the dot product of the two vectors
|
||||
// \sum_i x[i]*y[i]
|
||||
//
|
||||
// Float32 implementations are autogenerated and not directly tested.
|
||||
func (Implementation) Sdot(n int, x []float32, incX int, y []float32, incY int) float32 {
|
||||
if incX == 0 {
|
||||
panic(zeroIncX)
|
||||
}
|
||||
if incY == 0 {
|
||||
panic(zeroIncY)
|
||||
}
|
||||
if n <= 0 {
|
||||
if n == 0 {
|
||||
return 0
|
||||
}
|
||||
panic(nLT0)
|
||||
}
|
||||
if incX == 1 && incY == 1 {
|
||||
if len(x) < n {
|
||||
panic(shortX)
|
||||
}
|
||||
if len(y) < n {
|
||||
panic(shortY)
|
||||
}
|
||||
return f32.DotUnitary(x[:n], y[:n])
|
||||
}
|
||||
var ix, iy int
|
||||
if incX < 0 {
|
||||
ix = (-n + 1) * incX
|
||||
}
|
||||
if incY < 0 {
|
||||
iy = (-n + 1) * incY
|
||||
}
|
||||
if ix >= len(x) || ix+(n-1)*incX >= len(x) {
|
||||
panic(shortX)
|
||||
}
|
||||
if iy >= len(y) || iy+(n-1)*incY >= len(y) {
|
||||
panic(shortY)
|
||||
}
|
||||
return f32.DotInc(x, y, uintptr(n), uintptr(incX), uintptr(incY), uintptr(ix), uintptr(iy))
|
||||
}
|
||||
53
vendor/gonum.org/v1/gonum/blas/gonum/level1float32_sdsdot.go
generated
vendored
Normal file
53
vendor/gonum.org/v1/gonum/blas/gonum/level1float32_sdsdot.go
generated
vendored
Normal file
@@ -0,0 +1,53 @@
|
||||
// Code generated by "go generate gonum.org/v1/gonum/blas/gonum”; DO NOT EDIT.
|
||||
|
||||
// Copyright ©2015 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package gonum
|
||||
|
||||
import (
|
||||
"gonum.org/v1/gonum/internal/asm/f32"
|
||||
)
|
||||
|
||||
// Sdsdot computes the dot product of the two vectors plus a constant
|
||||
// alpha + \sum_i x[i]*y[i]
|
||||
//
|
||||
// Float32 implementations are autogenerated and not directly tested.
|
||||
func (Implementation) Sdsdot(n int, alpha float32, x []float32, incX int, y []float32, incY int) float32 {
|
||||
if incX == 0 {
|
||||
panic(zeroIncX)
|
||||
}
|
||||
if incY == 0 {
|
||||
panic(zeroIncY)
|
||||
}
|
||||
if n <= 0 {
|
||||
if n == 0 {
|
||||
return 0
|
||||
}
|
||||
panic(nLT0)
|
||||
}
|
||||
if incX == 1 && incY == 1 {
|
||||
if len(x) < n {
|
||||
panic(shortX)
|
||||
}
|
||||
if len(y) < n {
|
||||
panic(shortY)
|
||||
}
|
||||
return alpha + float32(f32.DdotUnitary(x[:n], y[:n]))
|
||||
}
|
||||
var ix, iy int
|
||||
if incX < 0 {
|
||||
ix = (-n + 1) * incX
|
||||
}
|
||||
if incY < 0 {
|
||||
iy = (-n + 1) * incY
|
||||
}
|
||||
if ix >= len(x) || ix+(n-1)*incX >= len(x) {
|
||||
panic(shortX)
|
||||
}
|
||||
if iy >= len(y) || iy+(n-1)*incY >= len(y) {
|
||||
panic(shortY)
|
||||
}
|
||||
return alpha + float32(f32.DdotInc(x, y, uintptr(n), uintptr(incX), uintptr(incY), uintptr(ix), uintptr(iy)))
|
||||
}
|
||||
620
vendor/gonum.org/v1/gonum/blas/gonum/level1float64.go
generated
vendored
Normal file
620
vendor/gonum.org/v1/gonum/blas/gonum/level1float64.go
generated
vendored
Normal file
@@ -0,0 +1,620 @@
|
||||
// Copyright ©2015 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package gonum
|
||||
|
||||
import (
|
||||
"math"
|
||||
|
||||
"gonum.org/v1/gonum/blas"
|
||||
"gonum.org/v1/gonum/internal/asm/f64"
|
||||
)
|
||||
|
||||
var _ blas.Float64Level1 = Implementation{}
|
||||
|
||||
// Dnrm2 computes the Euclidean norm of a vector,
|
||||
// sqrt(\sum_i x[i] * x[i]).
|
||||
// This function returns 0 if incX is negative.
|
||||
func (Implementation) Dnrm2(n int, x []float64, incX int) float64 {
|
||||
if incX < 1 {
|
||||
if incX == 0 {
|
||||
panic(zeroIncX)
|
||||
}
|
||||
return 0
|
||||
}
|
||||
if len(x) <= (n-1)*incX {
|
||||
panic(shortX)
|
||||
}
|
||||
if n < 2 {
|
||||
if n == 1 {
|
||||
return math.Abs(x[0])
|
||||
}
|
||||
if n == 0 {
|
||||
return 0
|
||||
}
|
||||
panic(nLT0)
|
||||
}
|
||||
var (
|
||||
scale float64 = 0
|
||||
sumSquares float64 = 1
|
||||
)
|
||||
if incX == 1 {
|
||||
x = x[:n]
|
||||
for _, v := range x {
|
||||
if v == 0 {
|
||||
continue
|
||||
}
|
||||
absxi := math.Abs(v)
|
||||
if math.IsNaN(absxi) {
|
||||
return math.NaN()
|
||||
}
|
||||
if scale < absxi {
|
||||
sumSquares = 1 + sumSquares*(scale/absxi)*(scale/absxi)
|
||||
scale = absxi
|
||||
} else {
|
||||
sumSquares = sumSquares + (absxi/scale)*(absxi/scale)
|
||||
}
|
||||
}
|
||||
if math.IsInf(scale, 1) {
|
||||
return math.Inf(1)
|
||||
}
|
||||
return scale * math.Sqrt(sumSquares)
|
||||
}
|
||||
for ix := 0; ix < n*incX; ix += incX {
|
||||
val := x[ix]
|
||||
if val == 0 {
|
||||
continue
|
||||
}
|
||||
absxi := math.Abs(val)
|
||||
if math.IsNaN(absxi) {
|
||||
return math.NaN()
|
||||
}
|
||||
if scale < absxi {
|
||||
sumSquares = 1 + sumSquares*(scale/absxi)*(scale/absxi)
|
||||
scale = absxi
|
||||
} else {
|
||||
sumSquares = sumSquares + (absxi/scale)*(absxi/scale)
|
||||
}
|
||||
}
|
||||
if math.IsInf(scale, 1) {
|
||||
return math.Inf(1)
|
||||
}
|
||||
return scale * math.Sqrt(sumSquares)
|
||||
}
|
||||
|
||||
// Dasum computes the sum of the absolute values of the elements of x.
|
||||
// \sum_i |x[i]|
|
||||
// Dasum returns 0 if incX is negative.
|
||||
func (Implementation) Dasum(n int, x []float64, incX int) float64 {
|
||||
var sum float64
|
||||
if n < 0 {
|
||||
panic(nLT0)
|
||||
}
|
||||
if incX < 1 {
|
||||
if incX == 0 {
|
||||
panic(zeroIncX)
|
||||
}
|
||||
return 0
|
||||
}
|
||||
if len(x) <= (n-1)*incX {
|
||||
panic(shortX)
|
||||
}
|
||||
if incX == 1 {
|
||||
x = x[:n]
|
||||
for _, v := range x {
|
||||
sum += math.Abs(v)
|
||||
}
|
||||
return sum
|
||||
}
|
||||
for i := 0; i < n; i++ {
|
||||
sum += math.Abs(x[i*incX])
|
||||
}
|
||||
return sum
|
||||
}
|
||||
|
||||
// Idamax returns the index of an element of x with the largest absolute value.
|
||||
// If there are multiple such indices the earliest is returned.
|
||||
// Idamax returns -1 if n == 0.
|
||||
func (Implementation) Idamax(n int, x []float64, incX int) int {
|
||||
if incX < 1 {
|
||||
if incX == 0 {
|
||||
panic(zeroIncX)
|
||||
}
|
||||
return -1
|
||||
}
|
||||
if len(x) <= (n-1)*incX {
|
||||
panic(shortX)
|
||||
}
|
||||
if n < 2 {
|
||||
if n == 1 {
|
||||
return 0
|
||||
}
|
||||
if n == 0 {
|
||||
return -1 // Netlib returns invalid index when n == 0.
|
||||
}
|
||||
panic(nLT0)
|
||||
}
|
||||
idx := 0
|
||||
max := math.Abs(x[0])
|
||||
if incX == 1 {
|
||||
for i, v := range x[:n] {
|
||||
absV := math.Abs(v)
|
||||
if absV > max {
|
||||
max = absV
|
||||
idx = i
|
||||
}
|
||||
}
|
||||
return idx
|
||||
}
|
||||
ix := incX
|
||||
for i := 1; i < n; i++ {
|
||||
v := x[ix]
|
||||
absV := math.Abs(v)
|
||||
if absV > max {
|
||||
max = absV
|
||||
idx = i
|
||||
}
|
||||
ix += incX
|
||||
}
|
||||
return idx
|
||||
}
|
||||
|
||||
// Dswap exchanges the elements of two vectors.
|
||||
// x[i], y[i] = y[i], x[i] for all i
|
||||
func (Implementation) Dswap(n int, x []float64, incX int, y []float64, incY int) {
|
||||
if incX == 0 {
|
||||
panic(zeroIncX)
|
||||
}
|
||||
if incY == 0 {
|
||||
panic(zeroIncY)
|
||||
}
|
||||
if n < 1 {
|
||||
if n == 0 {
|
||||
return
|
||||
}
|
||||
panic(nLT0)
|
||||
}
|
||||
if (incX > 0 && len(x) <= (n-1)*incX) || (incX < 0 && len(x) <= (1-n)*incX) {
|
||||
panic(shortX)
|
||||
}
|
||||
if (incY > 0 && len(y) <= (n-1)*incY) || (incY < 0 && len(y) <= (1-n)*incY) {
|
||||
panic(shortY)
|
||||
}
|
||||
if incX == 1 && incY == 1 {
|
||||
x = x[:n]
|
||||
for i, v := range x {
|
||||
x[i], y[i] = y[i], v
|
||||
}
|
||||
return
|
||||
}
|
||||
var ix, iy int
|
||||
if incX < 0 {
|
||||
ix = (-n + 1) * incX
|
||||
}
|
||||
if incY < 0 {
|
||||
iy = (-n + 1) * incY
|
||||
}
|
||||
for i := 0; i < n; i++ {
|
||||
x[ix], y[iy] = y[iy], x[ix]
|
||||
ix += incX
|
||||
iy += incY
|
||||
}
|
||||
}
|
||||
|
||||
// Dcopy copies the elements of x into the elements of y.
|
||||
// y[i] = x[i] for all i
|
||||
func (Implementation) Dcopy(n int, x []float64, incX int, y []float64, incY int) {
|
||||
if incX == 0 {
|
||||
panic(zeroIncX)
|
||||
}
|
||||
if incY == 0 {
|
||||
panic(zeroIncY)
|
||||
}
|
||||
if n < 1 {
|
||||
if n == 0 {
|
||||
return
|
||||
}
|
||||
panic(nLT0)
|
||||
}
|
||||
if (incX > 0 && len(x) <= (n-1)*incX) || (incX < 0 && len(x) <= (1-n)*incX) {
|
||||
panic(shortX)
|
||||
}
|
||||
if (incY > 0 && len(y) <= (n-1)*incY) || (incY < 0 && len(y) <= (1-n)*incY) {
|
||||
panic(shortY)
|
||||
}
|
||||
if incX == 1 && incY == 1 {
|
||||
copy(y[:n], x[:n])
|
||||
return
|
||||
}
|
||||
var ix, iy int
|
||||
if incX < 0 {
|
||||
ix = (-n + 1) * incX
|
||||
}
|
||||
if incY < 0 {
|
||||
iy = (-n + 1) * incY
|
||||
}
|
||||
for i := 0; i < n; i++ {
|
||||
y[iy] = x[ix]
|
||||
ix += incX
|
||||
iy += incY
|
||||
}
|
||||
}
|
||||
|
||||
// Daxpy adds alpha times x to y
|
||||
// y[i] += alpha * x[i] for all i
|
||||
func (Implementation) Daxpy(n int, alpha float64, x []float64, incX int, y []float64, incY int) {
|
||||
if incX == 0 {
|
||||
panic(zeroIncX)
|
||||
}
|
||||
if incY == 0 {
|
||||
panic(zeroIncY)
|
||||
}
|
||||
if n < 1 {
|
||||
if n == 0 {
|
||||
return
|
||||
}
|
||||
panic(nLT0)
|
||||
}
|
||||
if (incX > 0 && len(x) <= (n-1)*incX) || (incX < 0 && len(x) <= (1-n)*incX) {
|
||||
panic(shortX)
|
||||
}
|
||||
if (incY > 0 && len(y) <= (n-1)*incY) || (incY < 0 && len(y) <= (1-n)*incY) {
|
||||
panic(shortY)
|
||||
}
|
||||
if alpha == 0 {
|
||||
return
|
||||
}
|
||||
if incX == 1 && incY == 1 {
|
||||
f64.AxpyUnitary(alpha, x[:n], y[:n])
|
||||
return
|
||||
}
|
||||
var ix, iy int
|
||||
if incX < 0 {
|
||||
ix = (-n + 1) * incX
|
||||
}
|
||||
if incY < 0 {
|
||||
iy = (-n + 1) * incY
|
||||
}
|
||||
f64.AxpyInc(alpha, x, y, uintptr(n), uintptr(incX), uintptr(incY), uintptr(ix), uintptr(iy))
|
||||
}
|
||||
|
||||
// Drotg computes the plane rotation
|
||||
// _ _ _ _ _ _
|
||||
// | c s | | a | | r |
|
||||
// | -s c | * | b | = | 0 |
|
||||
// ‾ ‾ ‾ ‾ ‾ ‾
|
||||
// where
|
||||
// r = ±√(a^2 + b^2)
|
||||
// c = a/r, the cosine of the plane rotation
|
||||
// s = b/r, the sine of the plane rotation
|
||||
//
|
||||
// NOTE: There is a discrepancy between the reference implementation and the BLAS
|
||||
// technical manual regarding the sign for r when a or b are zero.
|
||||
// Drotg agrees with the definition in the manual and other
|
||||
// common BLAS implementations.
|
||||
func (Implementation) Drotg(a, b float64) (c, s, r, z float64) {
|
||||
if b == 0 && a == 0 {
|
||||
return 1, 0, a, 0
|
||||
}
|
||||
absA := math.Abs(a)
|
||||
absB := math.Abs(b)
|
||||
aGTb := absA > absB
|
||||
r = math.Hypot(a, b)
|
||||
if aGTb {
|
||||
r = math.Copysign(r, a)
|
||||
} else {
|
||||
r = math.Copysign(r, b)
|
||||
}
|
||||
c = a / r
|
||||
s = b / r
|
||||
if aGTb {
|
||||
z = s
|
||||
} else if c != 0 { // r == 0 case handled above
|
||||
z = 1 / c
|
||||
} else {
|
||||
z = 1
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// Drotmg computes the modified Givens rotation. See
|
||||
// http://www.netlib.org/lapack/explore-html/df/deb/drotmg_8f.html
|
||||
// for more details.
|
||||
func (Implementation) Drotmg(d1, d2, x1, y1 float64) (p blas.DrotmParams, rd1, rd2, rx1 float64) {
|
||||
// The implementation of Drotmg used here is taken from Hopkins 1997
|
||||
// Appendix A: https://doi.org/10.1145/289251.289253
|
||||
// with the exception of the gam constants below.
|
||||
|
||||
const (
|
||||
gam = 4096.0
|
||||
gamsq = gam * gam
|
||||
rgamsq = 1.0 / gamsq
|
||||
)
|
||||
|
||||
if d1 < 0 {
|
||||
p.Flag = blas.Rescaling // Error state.
|
||||
return p, 0, 0, 0
|
||||
}
|
||||
|
||||
if d2 == 0 || y1 == 0 {
|
||||
p.Flag = blas.Identity
|
||||
return p, d1, d2, x1
|
||||
}
|
||||
|
||||
var h11, h12, h21, h22 float64
|
||||
if (d1 == 0 || x1 == 0) && d2 > 0 {
|
||||
p.Flag = blas.Diagonal
|
||||
h12 = 1
|
||||
h21 = -1
|
||||
x1 = y1
|
||||
d1, d2 = d2, d1
|
||||
} else {
|
||||
p2 := d2 * y1
|
||||
p1 := d1 * x1
|
||||
q2 := p2 * y1
|
||||
q1 := p1 * x1
|
||||
if math.Abs(q1) > math.Abs(q2) {
|
||||
p.Flag = blas.OffDiagonal
|
||||
h11 = 1
|
||||
h22 = 1
|
||||
h21 = -y1 / x1
|
||||
h12 = p2 / p1
|
||||
u := 1 - h12*h21
|
||||
if u <= 0 {
|
||||
p.Flag = blas.Rescaling // Error state.
|
||||
return p, 0, 0, 0
|
||||
}
|
||||
|
||||
d1 /= u
|
||||
d2 /= u
|
||||
x1 *= u
|
||||
} else {
|
||||
if q2 < 0 {
|
||||
p.Flag = blas.Rescaling // Error state.
|
||||
return p, 0, 0, 0
|
||||
}
|
||||
|
||||
p.Flag = blas.Diagonal
|
||||
h21 = -1
|
||||
h12 = 1
|
||||
h11 = p1 / p2
|
||||
h22 = x1 / y1
|
||||
u := 1 + h11*h22
|
||||
d1, d2 = d2/u, d1/u
|
||||
x1 = y1 * u
|
||||
}
|
||||
}
|
||||
|
||||
for d1 <= rgamsq && d1 != 0 {
|
||||
p.Flag = blas.Rescaling
|
||||
d1 = (d1 * gam) * gam
|
||||
x1 /= gam
|
||||
h11 /= gam
|
||||
h12 /= gam
|
||||
}
|
||||
for d1 > gamsq {
|
||||
p.Flag = blas.Rescaling
|
||||
d1 = (d1 / gam) / gam
|
||||
x1 *= gam
|
||||
h11 *= gam
|
||||
h12 *= gam
|
||||
}
|
||||
|
||||
for math.Abs(d2) <= rgamsq && d2 != 0 {
|
||||
p.Flag = blas.Rescaling
|
||||
d2 = (d2 * gam) * gam
|
||||
h21 /= gam
|
||||
h22 /= gam
|
||||
}
|
||||
for math.Abs(d2) > gamsq {
|
||||
p.Flag = blas.Rescaling
|
||||
d2 = (d2 / gam) / gam
|
||||
h21 *= gam
|
||||
h22 *= gam
|
||||
}
|
||||
|
||||
switch p.Flag {
|
||||
case blas.Diagonal:
|
||||
p.H = [4]float64{0: h11, 3: h22}
|
||||
case blas.OffDiagonal:
|
||||
p.H = [4]float64{1: h21, 2: h12}
|
||||
case blas.Rescaling:
|
||||
p.H = [4]float64{h11, h21, h12, h22}
|
||||
default:
|
||||
panic(badFlag)
|
||||
}
|
||||
|
||||
return p, d1, d2, x1
|
||||
}
|
||||
|
||||
// Drot applies a plane transformation.
|
||||
// x[i] = c * x[i] + s * y[i]
|
||||
// y[i] = c * y[i] - s * x[i]
|
||||
func (Implementation) Drot(n int, x []float64, incX int, y []float64, incY int, c float64, s float64) {
|
||||
if incX == 0 {
|
||||
panic(zeroIncX)
|
||||
}
|
||||
if incY == 0 {
|
||||
panic(zeroIncY)
|
||||
}
|
||||
if n < 1 {
|
||||
if n == 0 {
|
||||
return
|
||||
}
|
||||
panic(nLT0)
|
||||
}
|
||||
if (incX > 0 && len(x) <= (n-1)*incX) || (incX < 0 && len(x) <= (1-n)*incX) {
|
||||
panic(shortX)
|
||||
}
|
||||
if (incY > 0 && len(y) <= (n-1)*incY) || (incY < 0 && len(y) <= (1-n)*incY) {
|
||||
panic(shortY)
|
||||
}
|
||||
if incX == 1 && incY == 1 {
|
||||
x = x[:n]
|
||||
for i, vx := range x {
|
||||
vy := y[i]
|
||||
x[i], y[i] = c*vx+s*vy, c*vy-s*vx
|
||||
}
|
||||
return
|
||||
}
|
||||
var ix, iy int
|
||||
if incX < 0 {
|
||||
ix = (-n + 1) * incX
|
||||
}
|
||||
if incY < 0 {
|
||||
iy = (-n + 1) * incY
|
||||
}
|
||||
for i := 0; i < n; i++ {
|
||||
vx := x[ix]
|
||||
vy := y[iy]
|
||||
x[ix], y[iy] = c*vx+s*vy, c*vy-s*vx
|
||||
ix += incX
|
||||
iy += incY
|
||||
}
|
||||
}
|
||||
|
||||
// Drotm applies the modified Givens rotation to the 2×n matrix.
|
||||
func (Implementation) Drotm(n int, x []float64, incX int, y []float64, incY int, p blas.DrotmParams) {
|
||||
if incX == 0 {
|
||||
panic(zeroIncX)
|
||||
}
|
||||
if incY == 0 {
|
||||
panic(zeroIncY)
|
||||
}
|
||||
if n <= 0 {
|
||||
if n == 0 {
|
||||
return
|
||||
}
|
||||
panic(nLT0)
|
||||
}
|
||||
if (incX > 0 && len(x) <= (n-1)*incX) || (incX < 0 && len(x) <= (1-n)*incX) {
|
||||
panic(shortX)
|
||||
}
|
||||
if (incY > 0 && len(y) <= (n-1)*incY) || (incY < 0 && len(y) <= (1-n)*incY) {
|
||||
panic(shortY)
|
||||
}
|
||||
|
||||
if p.Flag == blas.Identity {
|
||||
return
|
||||
}
|
||||
|
||||
switch p.Flag {
|
||||
case blas.Rescaling:
|
||||
h11 := p.H[0]
|
||||
h12 := p.H[2]
|
||||
h21 := p.H[1]
|
||||
h22 := p.H[3]
|
||||
if incX == 1 && incY == 1 {
|
||||
x = x[:n]
|
||||
for i, vx := range x {
|
||||
vy := y[i]
|
||||
x[i], y[i] = vx*h11+vy*h12, vx*h21+vy*h22
|
||||
}
|
||||
return
|
||||
}
|
||||
var ix, iy int
|
||||
if incX < 0 {
|
||||
ix = (-n + 1) * incX
|
||||
}
|
||||
if incY < 0 {
|
||||
iy = (-n + 1) * incY
|
||||
}
|
||||
for i := 0; i < n; i++ {
|
||||
vx := x[ix]
|
||||
vy := y[iy]
|
||||
x[ix], y[iy] = vx*h11+vy*h12, vx*h21+vy*h22
|
||||
ix += incX
|
||||
iy += incY
|
||||
}
|
||||
case blas.OffDiagonal:
|
||||
h12 := p.H[2]
|
||||
h21 := p.H[1]
|
||||
if incX == 1 && incY == 1 {
|
||||
x = x[:n]
|
||||
for i, vx := range x {
|
||||
vy := y[i]
|
||||
x[i], y[i] = vx+vy*h12, vx*h21+vy
|
||||
}
|
||||
return
|
||||
}
|
||||
var ix, iy int
|
||||
if incX < 0 {
|
||||
ix = (-n + 1) * incX
|
||||
}
|
||||
if incY < 0 {
|
||||
iy = (-n + 1) * incY
|
||||
}
|
||||
for i := 0; i < n; i++ {
|
||||
vx := x[ix]
|
||||
vy := y[iy]
|
||||
x[ix], y[iy] = vx+vy*h12, vx*h21+vy
|
||||
ix += incX
|
||||
iy += incY
|
||||
}
|
||||
case blas.Diagonal:
|
||||
h11 := p.H[0]
|
||||
h22 := p.H[3]
|
||||
if incX == 1 && incY == 1 {
|
||||
x = x[:n]
|
||||
for i, vx := range x {
|
||||
vy := y[i]
|
||||
x[i], y[i] = vx*h11+vy, -vx+vy*h22
|
||||
}
|
||||
return
|
||||
}
|
||||
var ix, iy int
|
||||
if incX < 0 {
|
||||
ix = (-n + 1) * incX
|
||||
}
|
||||
if incY < 0 {
|
||||
iy = (-n + 1) * incY
|
||||
}
|
||||
for i := 0; i < n; i++ {
|
||||
vx := x[ix]
|
||||
vy := y[iy]
|
||||
x[ix], y[iy] = vx*h11+vy, -vx+vy*h22
|
||||
ix += incX
|
||||
iy += incY
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Dscal scales x by alpha.
|
||||
// x[i] *= alpha
|
||||
// Dscal has no effect if incX < 0.
|
||||
func (Implementation) Dscal(n int, alpha float64, x []float64, incX int) {
|
||||
if incX < 1 {
|
||||
if incX == 0 {
|
||||
panic(zeroIncX)
|
||||
}
|
||||
return
|
||||
}
|
||||
if n < 1 {
|
||||
if n == 0 {
|
||||
return
|
||||
}
|
||||
panic(nLT0)
|
||||
}
|
||||
if (n-1)*incX >= len(x) {
|
||||
panic(shortX)
|
||||
}
|
||||
if alpha == 0 {
|
||||
if incX == 1 {
|
||||
x = x[:n]
|
||||
for i := range x {
|
||||
x[i] = 0
|
||||
}
|
||||
return
|
||||
}
|
||||
for ix := 0; ix < n*incX; ix += incX {
|
||||
x[ix] = 0
|
||||
}
|
||||
return
|
||||
}
|
||||
if incX == 1 {
|
||||
f64.ScalUnitary(alpha, x[:n])
|
||||
return
|
||||
}
|
||||
f64.ScalInc(alpha, x, uintptr(n), uintptr(incX))
|
||||
}
|
||||
49
vendor/gonum.org/v1/gonum/blas/gonum/level1float64_ddot.go
generated
vendored
Normal file
49
vendor/gonum.org/v1/gonum/blas/gonum/level1float64_ddot.go
generated
vendored
Normal file
@@ -0,0 +1,49 @@
|
||||
// Copyright ©2015 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package gonum
|
||||
|
||||
import (
|
||||
"gonum.org/v1/gonum/internal/asm/f64"
|
||||
)
|
||||
|
||||
// Ddot computes the dot product of the two vectors
|
||||
// \sum_i x[i]*y[i]
|
||||
func (Implementation) Ddot(n int, x []float64, incX int, y []float64, incY int) float64 {
|
||||
if incX == 0 {
|
||||
panic(zeroIncX)
|
||||
}
|
||||
if incY == 0 {
|
||||
panic(zeroIncY)
|
||||
}
|
||||
if n <= 0 {
|
||||
if n == 0 {
|
||||
return 0
|
||||
}
|
||||
panic(nLT0)
|
||||
}
|
||||
if incX == 1 && incY == 1 {
|
||||
if len(x) < n {
|
||||
panic(shortX)
|
||||
}
|
||||
if len(y) < n {
|
||||
panic(shortY)
|
||||
}
|
||||
return f64.DotUnitary(x[:n], y[:n])
|
||||
}
|
||||
var ix, iy int
|
||||
if incX < 0 {
|
||||
ix = (-n + 1) * incX
|
||||
}
|
||||
if incY < 0 {
|
||||
iy = (-n + 1) * incY
|
||||
}
|
||||
if ix >= len(x) || ix+(n-1)*incX >= len(x) {
|
||||
panic(shortX)
|
||||
}
|
||||
if iy >= len(y) || iy+(n-1)*incY >= len(y) {
|
||||
panic(shortY)
|
||||
}
|
||||
return f64.DotInc(x, y, uintptr(n), uintptr(incX), uintptr(incY), uintptr(ix), uintptr(iy))
|
||||
}
|
||||
2906
vendor/gonum.org/v1/gonum/blas/gonum/level2cmplx128.go
generated
vendored
Normal file
2906
vendor/gonum.org/v1/gonum/blas/gonum/level2cmplx128.go
generated
vendored
Normal file
File diff suppressed because it is too large
Load Diff
2942
vendor/gonum.org/v1/gonum/blas/gonum/level2cmplx64.go
generated
vendored
Normal file
2942
vendor/gonum.org/v1/gonum/blas/gonum/level2cmplx64.go
generated
vendored
Normal file
File diff suppressed because it is too large
Load Diff
2296
vendor/gonum.org/v1/gonum/blas/gonum/level2float32.go
generated
vendored
Normal file
2296
vendor/gonum.org/v1/gonum/blas/gonum/level2float32.go
generated
vendored
Normal file
File diff suppressed because it is too large
Load Diff
2264
vendor/gonum.org/v1/gonum/blas/gonum/level2float64.go
generated
vendored
Normal file
2264
vendor/gonum.org/v1/gonum/blas/gonum/level2float64.go
generated
vendored
Normal file
File diff suppressed because it is too large
Load Diff
1715
vendor/gonum.org/v1/gonum/blas/gonum/level3cmplx128.go
generated
vendored
Normal file
1715
vendor/gonum.org/v1/gonum/blas/gonum/level3cmplx128.go
generated
vendored
Normal file
File diff suppressed because it is too large
Load Diff
1735
vendor/gonum.org/v1/gonum/blas/gonum/level3cmplx64.go
generated
vendored
Normal file
1735
vendor/gonum.org/v1/gonum/blas/gonum/level3cmplx64.go
generated
vendored
Normal file
File diff suppressed because it is too large
Load Diff
876
vendor/gonum.org/v1/gonum/blas/gonum/level3float32.go
generated
vendored
Normal file
876
vendor/gonum.org/v1/gonum/blas/gonum/level3float32.go
generated
vendored
Normal file
@@ -0,0 +1,876 @@
|
||||
// Code generated by "go generate gonum.org/v1/gonum/blas/gonum”; DO NOT EDIT.
|
||||
|
||||
// Copyright ©2014 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package gonum
|
||||
|
||||
import (
|
||||
"gonum.org/v1/gonum/blas"
|
||||
"gonum.org/v1/gonum/internal/asm/f32"
|
||||
)
|
||||
|
||||
var _ blas.Float32Level3 = Implementation{}
|
||||
|
||||
// Strsm solves one of the matrix equations
|
||||
// A * X = alpha * B if tA == blas.NoTrans and side == blas.Left
|
||||
// A^T * X = alpha * B if tA == blas.Trans or blas.ConjTrans, and side == blas.Left
|
||||
// X * A = alpha * B if tA == blas.NoTrans and side == blas.Right
|
||||
// X * A^T = alpha * B if tA == blas.Trans or blas.ConjTrans, and side == blas.Right
|
||||
// where A is an n×n or m×m triangular matrix, X and B are m×n matrices, and alpha is a
|
||||
// scalar.
|
||||
//
|
||||
// At entry to the function, X contains the values of B, and the result is
|
||||
// stored in-place into X.
|
||||
//
|
||||
// No check is made that A is invertible.
|
||||
//
|
||||
// Float32 implementations are autogenerated and not directly tested.
|
||||
func (Implementation) Strsm(s blas.Side, ul blas.Uplo, tA blas.Transpose, d blas.Diag, m, n int, alpha float32, a []float32, lda int, b []float32, ldb int) {
|
||||
if s != blas.Left && s != blas.Right {
|
||||
panic(badSide)
|
||||
}
|
||||
if ul != blas.Lower && ul != blas.Upper {
|
||||
panic(badUplo)
|
||||
}
|
||||
if tA != blas.NoTrans && tA != blas.Trans && tA != blas.ConjTrans {
|
||||
panic(badTranspose)
|
||||
}
|
||||
if d != blas.NonUnit && d != blas.Unit {
|
||||
panic(badDiag)
|
||||
}
|
||||
if m < 0 {
|
||||
panic(mLT0)
|
||||
}
|
||||
if n < 0 {
|
||||
panic(nLT0)
|
||||
}
|
||||
k := n
|
||||
if s == blas.Left {
|
||||
k = m
|
||||
}
|
||||
if lda < max(1, k) {
|
||||
panic(badLdA)
|
||||
}
|
||||
if ldb < max(1, n) {
|
||||
panic(badLdB)
|
||||
}
|
||||
|
||||
// Quick return if possible.
|
||||
if m == 0 || n == 0 {
|
||||
return
|
||||
}
|
||||
|
||||
// For zero matrix size the following slice length checks are trivially satisfied.
|
||||
if len(a) < lda*(k-1)+k {
|
||||
panic(shortA)
|
||||
}
|
||||
if len(b) < ldb*(m-1)+n {
|
||||
panic(shortB)
|
||||
}
|
||||
|
||||
if alpha == 0 {
|
||||
for i := 0; i < m; i++ {
|
||||
btmp := b[i*ldb : i*ldb+n]
|
||||
for j := range btmp {
|
||||
btmp[j] = 0
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
nonUnit := d == blas.NonUnit
|
||||
if s == blas.Left {
|
||||
if tA == blas.NoTrans {
|
||||
if ul == blas.Upper {
|
||||
for i := m - 1; i >= 0; i-- {
|
||||
btmp := b[i*ldb : i*ldb+n]
|
||||
if alpha != 1 {
|
||||
f32.ScalUnitary(alpha, btmp)
|
||||
}
|
||||
for ka, va := range a[i*lda+i+1 : i*lda+m] {
|
||||
if va != 0 {
|
||||
k := ka + i + 1
|
||||
f32.AxpyUnitary(-va, b[k*ldb:k*ldb+n], btmp)
|
||||
}
|
||||
}
|
||||
if nonUnit {
|
||||
tmp := 1 / a[i*lda+i]
|
||||
f32.ScalUnitary(tmp, btmp)
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
for i := 0; i < m; i++ {
|
||||
btmp := b[i*ldb : i*ldb+n]
|
||||
if alpha != 1 {
|
||||
f32.ScalUnitary(alpha, btmp)
|
||||
}
|
||||
for k, va := range a[i*lda : i*lda+i] {
|
||||
if va != 0 {
|
||||
f32.AxpyUnitary(-va, b[k*ldb:k*ldb+n], btmp)
|
||||
}
|
||||
}
|
||||
if nonUnit {
|
||||
tmp := 1 / a[i*lda+i]
|
||||
f32.ScalUnitary(tmp, btmp)
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
// Cases where a is transposed
|
||||
if ul == blas.Upper {
|
||||
for k := 0; k < m; k++ {
|
||||
btmpk := b[k*ldb : k*ldb+n]
|
||||
if nonUnit {
|
||||
tmp := 1 / a[k*lda+k]
|
||||
f32.ScalUnitary(tmp, btmpk)
|
||||
}
|
||||
for ia, va := range a[k*lda+k+1 : k*lda+m] {
|
||||
if va != 0 {
|
||||
i := ia + k + 1
|
||||
f32.AxpyUnitary(-va, btmpk, b[i*ldb:i*ldb+n])
|
||||
}
|
||||
}
|
||||
if alpha != 1 {
|
||||
f32.ScalUnitary(alpha, btmpk)
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
for k := m - 1; k >= 0; k-- {
|
||||
btmpk := b[k*ldb : k*ldb+n]
|
||||
if nonUnit {
|
||||
tmp := 1 / a[k*lda+k]
|
||||
f32.ScalUnitary(tmp, btmpk)
|
||||
}
|
||||
for i, va := range a[k*lda : k*lda+k] {
|
||||
if va != 0 {
|
||||
f32.AxpyUnitary(-va, btmpk, b[i*ldb:i*ldb+n])
|
||||
}
|
||||
}
|
||||
if alpha != 1 {
|
||||
f32.ScalUnitary(alpha, btmpk)
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
// Cases where a is to the right of X.
|
||||
if tA == blas.NoTrans {
|
||||
if ul == blas.Upper {
|
||||
for i := 0; i < m; i++ {
|
||||
btmp := b[i*ldb : i*ldb+n]
|
||||
if alpha != 1 {
|
||||
f32.ScalUnitary(alpha, btmp)
|
||||
}
|
||||
for k, vb := range btmp {
|
||||
if vb == 0 {
|
||||
continue
|
||||
}
|
||||
if nonUnit {
|
||||
btmp[k] /= a[k*lda+k]
|
||||
}
|
||||
f32.AxpyUnitary(-btmp[k], a[k*lda+k+1:k*lda+n], btmp[k+1:n])
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
for i := 0; i < m; i++ {
|
||||
btmp := b[i*ldb : i*ldb+n]
|
||||
if alpha != 1 {
|
||||
f32.ScalUnitary(alpha, btmp)
|
||||
}
|
||||
for k := n - 1; k >= 0; k-- {
|
||||
if btmp[k] == 0 {
|
||||
continue
|
||||
}
|
||||
if nonUnit {
|
||||
btmp[k] /= a[k*lda+k]
|
||||
}
|
||||
f32.AxpyUnitary(-btmp[k], a[k*lda:k*lda+k], btmp[:k])
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
// Cases where a is transposed.
|
||||
if ul == blas.Upper {
|
||||
for i := 0; i < m; i++ {
|
||||
btmp := b[i*ldb : i*ldb+n]
|
||||
for j := n - 1; j >= 0; j-- {
|
||||
tmp := alpha*btmp[j] - f32.DotUnitary(a[j*lda+j+1:j*lda+n], btmp[j+1:])
|
||||
if nonUnit {
|
||||
tmp /= a[j*lda+j]
|
||||
}
|
||||
btmp[j] = tmp
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
for i := 0; i < m; i++ {
|
||||
btmp := b[i*ldb : i*ldb+n]
|
||||
for j := 0; j < n; j++ {
|
||||
tmp := alpha*btmp[j] - f32.DotUnitary(a[j*lda:j*lda+j], btmp[:j])
|
||||
if nonUnit {
|
||||
tmp /= a[j*lda+j]
|
||||
}
|
||||
btmp[j] = tmp
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Ssymm performs one of the matrix-matrix operations
|
||||
// C = alpha * A * B + beta * C if side == blas.Left
|
||||
// C = alpha * B * A + beta * C if side == blas.Right
|
||||
// where A is an n×n or m×m symmetric matrix, B and C are m×n matrices, and alpha
|
||||
// is a scalar.
|
||||
//
|
||||
// Float32 implementations are autogenerated and not directly tested.
|
||||
func (Implementation) Ssymm(s blas.Side, ul blas.Uplo, m, n int, alpha float32, a []float32, lda int, b []float32, ldb int, beta float32, c []float32, ldc int) {
|
||||
if s != blas.Right && s != blas.Left {
|
||||
panic(badSide)
|
||||
}
|
||||
if ul != blas.Lower && ul != blas.Upper {
|
||||
panic(badUplo)
|
||||
}
|
||||
if m < 0 {
|
||||
panic(mLT0)
|
||||
}
|
||||
if n < 0 {
|
||||
panic(nLT0)
|
||||
}
|
||||
k := n
|
||||
if s == blas.Left {
|
||||
k = m
|
||||
}
|
||||
if lda < max(1, k) {
|
||||
panic(badLdA)
|
||||
}
|
||||
if ldb < max(1, n) {
|
||||
panic(badLdB)
|
||||
}
|
||||
if ldc < max(1, n) {
|
||||
panic(badLdC)
|
||||
}
|
||||
|
||||
// Quick return if possible.
|
||||
if m == 0 || n == 0 {
|
||||
return
|
||||
}
|
||||
|
||||
// For zero matrix size the following slice length checks are trivially satisfied.
|
||||
if len(a) < lda*(k-1)+k {
|
||||
panic(shortA)
|
||||
}
|
||||
if len(b) < ldb*(m-1)+n {
|
||||
panic(shortB)
|
||||
}
|
||||
if len(c) < ldc*(m-1)+n {
|
||||
panic(shortC)
|
||||
}
|
||||
|
||||
// Quick return if possible.
|
||||
if alpha == 0 && beta == 1 {
|
||||
return
|
||||
}
|
||||
|
||||
if alpha == 0 {
|
||||
if beta == 0 {
|
||||
for i := 0; i < m; i++ {
|
||||
ctmp := c[i*ldc : i*ldc+n]
|
||||
for j := range ctmp {
|
||||
ctmp[j] = 0
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
for i := 0; i < m; i++ {
|
||||
ctmp := c[i*ldc : i*ldc+n]
|
||||
for j := 0; j < n; j++ {
|
||||
ctmp[j] *= beta
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
isUpper := ul == blas.Upper
|
||||
if s == blas.Left {
|
||||
for i := 0; i < m; i++ {
|
||||
atmp := alpha * a[i*lda+i]
|
||||
btmp := b[i*ldb : i*ldb+n]
|
||||
ctmp := c[i*ldc : i*ldc+n]
|
||||
for j, v := range btmp {
|
||||
ctmp[j] *= beta
|
||||
ctmp[j] += atmp * v
|
||||
}
|
||||
|
||||
for k := 0; k < i; k++ {
|
||||
var atmp float32
|
||||
if isUpper {
|
||||
atmp = a[k*lda+i]
|
||||
} else {
|
||||
atmp = a[i*lda+k]
|
||||
}
|
||||
atmp *= alpha
|
||||
f32.AxpyUnitary(atmp, b[k*ldb:k*ldb+n], ctmp)
|
||||
}
|
||||
for k := i + 1; k < m; k++ {
|
||||
var atmp float32
|
||||
if isUpper {
|
||||
atmp = a[i*lda+k]
|
||||
} else {
|
||||
atmp = a[k*lda+i]
|
||||
}
|
||||
atmp *= alpha
|
||||
f32.AxpyUnitary(atmp, b[k*ldb:k*ldb+n], ctmp)
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
if isUpper {
|
||||
for i := 0; i < m; i++ {
|
||||
for j := n - 1; j >= 0; j-- {
|
||||
tmp := alpha * b[i*ldb+j]
|
||||
var tmp2 float32
|
||||
atmp := a[j*lda+j+1 : j*lda+n]
|
||||
btmp := b[i*ldb+j+1 : i*ldb+n]
|
||||
ctmp := c[i*ldc+j+1 : i*ldc+n]
|
||||
for k, v := range atmp {
|
||||
ctmp[k] += tmp * v
|
||||
tmp2 += btmp[k] * v
|
||||
}
|
||||
c[i*ldc+j] *= beta
|
||||
c[i*ldc+j] += tmp*a[j*lda+j] + alpha*tmp2
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
for i := 0; i < m; i++ {
|
||||
for j := 0; j < n; j++ {
|
||||
tmp := alpha * b[i*ldb+j]
|
||||
var tmp2 float32
|
||||
atmp := a[j*lda : j*lda+j]
|
||||
btmp := b[i*ldb : i*ldb+j]
|
||||
ctmp := c[i*ldc : i*ldc+j]
|
||||
for k, v := range atmp {
|
||||
ctmp[k] += tmp * v
|
||||
tmp2 += btmp[k] * v
|
||||
}
|
||||
c[i*ldc+j] *= beta
|
||||
c[i*ldc+j] += tmp*a[j*lda+j] + alpha*tmp2
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Ssyrk performs one of the symmetric rank-k operations
|
||||
// C = alpha * A * A^T + beta * C if tA == blas.NoTrans
|
||||
// C = alpha * A^T * A + beta * C if tA == blas.Trans or tA == blas.ConjTrans
|
||||
// where A is an n×k or k×n matrix, C is an n×n symmetric matrix, and alpha and
|
||||
// beta are scalars.
|
||||
//
|
||||
// Float32 implementations are autogenerated and not directly tested.
|
||||
func (Implementation) Ssyrk(ul blas.Uplo, tA blas.Transpose, n, k int, alpha float32, a []float32, lda int, beta float32, c []float32, ldc int) {
|
||||
if ul != blas.Lower && ul != blas.Upper {
|
||||
panic(badUplo)
|
||||
}
|
||||
if tA != blas.Trans && tA != blas.NoTrans && tA != blas.ConjTrans {
|
||||
panic(badTranspose)
|
||||
}
|
||||
if n < 0 {
|
||||
panic(nLT0)
|
||||
}
|
||||
if k < 0 {
|
||||
panic(kLT0)
|
||||
}
|
||||
row, col := k, n
|
||||
if tA == blas.NoTrans {
|
||||
row, col = n, k
|
||||
}
|
||||
if lda < max(1, col) {
|
||||
panic(badLdA)
|
||||
}
|
||||
if ldc < max(1, n) {
|
||||
panic(badLdC)
|
||||
}
|
||||
|
||||
// Quick return if possible.
|
||||
if n == 0 {
|
||||
return
|
||||
}
|
||||
|
||||
// For zero matrix size the following slice length checks are trivially satisfied.
|
||||
if len(a) < lda*(row-1)+col {
|
||||
panic(shortA)
|
||||
}
|
||||
if len(c) < ldc*(n-1)+n {
|
||||
panic(shortC)
|
||||
}
|
||||
|
||||
if alpha == 0 {
|
||||
if beta == 0 {
|
||||
if ul == blas.Upper {
|
||||
for i := 0; i < n; i++ {
|
||||
ctmp := c[i*ldc+i : i*ldc+n]
|
||||
for j := range ctmp {
|
||||
ctmp[j] = 0
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
for i := 0; i < n; i++ {
|
||||
ctmp := c[i*ldc : i*ldc+i+1]
|
||||
for j := range ctmp {
|
||||
ctmp[j] = 0
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
if ul == blas.Upper {
|
||||
for i := 0; i < n; i++ {
|
||||
ctmp := c[i*ldc+i : i*ldc+n]
|
||||
for j := range ctmp {
|
||||
ctmp[j] *= beta
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
for i := 0; i < n; i++ {
|
||||
ctmp := c[i*ldc : i*ldc+i+1]
|
||||
for j := range ctmp {
|
||||
ctmp[j] *= beta
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
if tA == blas.NoTrans {
|
||||
if ul == blas.Upper {
|
||||
for i := 0; i < n; i++ {
|
||||
ctmp := c[i*ldc+i : i*ldc+n]
|
||||
atmp := a[i*lda : i*lda+k]
|
||||
if beta == 0 {
|
||||
for jc := range ctmp {
|
||||
j := jc + i
|
||||
ctmp[jc] = alpha * f32.DotUnitary(atmp, a[j*lda:j*lda+k])
|
||||
}
|
||||
} else {
|
||||
for jc, vc := range ctmp {
|
||||
j := jc + i
|
||||
ctmp[jc] = vc*beta + alpha*f32.DotUnitary(atmp, a[j*lda:j*lda+k])
|
||||
}
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
for i := 0; i < n; i++ {
|
||||
ctmp := c[i*ldc : i*ldc+i+1]
|
||||
atmp := a[i*lda : i*lda+k]
|
||||
if beta == 0 {
|
||||
for j := range ctmp {
|
||||
ctmp[j] = alpha * f32.DotUnitary(a[j*lda:j*lda+k], atmp)
|
||||
}
|
||||
} else {
|
||||
for j, vc := range ctmp {
|
||||
ctmp[j] = vc*beta + alpha*f32.DotUnitary(a[j*lda:j*lda+k], atmp)
|
||||
}
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
// Cases where a is transposed.
|
||||
if ul == blas.Upper {
|
||||
for i := 0; i < n; i++ {
|
||||
ctmp := c[i*ldc+i : i*ldc+n]
|
||||
if beta == 0 {
|
||||
for j := range ctmp {
|
||||
ctmp[j] = 0
|
||||
}
|
||||
} else if beta != 1 {
|
||||
for j := range ctmp {
|
||||
ctmp[j] *= beta
|
||||
}
|
||||
}
|
||||
for l := 0; l < k; l++ {
|
||||
tmp := alpha * a[l*lda+i]
|
||||
if tmp != 0 {
|
||||
f32.AxpyUnitary(tmp, a[l*lda+i:l*lda+n], ctmp)
|
||||
}
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
for i := 0; i < n; i++ {
|
||||
ctmp := c[i*ldc : i*ldc+i+1]
|
||||
if beta != 1 {
|
||||
for j := range ctmp {
|
||||
ctmp[j] *= beta
|
||||
}
|
||||
}
|
||||
for l := 0; l < k; l++ {
|
||||
tmp := alpha * a[l*lda+i]
|
||||
if tmp != 0 {
|
||||
f32.AxpyUnitary(tmp, a[l*lda:l*lda+i+1], ctmp)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Ssyr2k performs one of the symmetric rank 2k operations
|
||||
// C = alpha * A * B^T + alpha * B * A^T + beta * C if tA == blas.NoTrans
|
||||
// C = alpha * A^T * B + alpha * B^T * A + beta * C if tA == blas.Trans or tA == blas.ConjTrans
|
||||
// where A and B are n×k or k×n matrices, C is an n×n symmetric matrix, and
|
||||
// alpha and beta are scalars.
|
||||
//
|
||||
// Float32 implementations are autogenerated and not directly tested.
|
||||
func (Implementation) Ssyr2k(ul blas.Uplo, tA blas.Transpose, n, k int, alpha float32, a []float32, lda int, b []float32, ldb int, beta float32, c []float32, ldc int) {
|
||||
if ul != blas.Lower && ul != blas.Upper {
|
||||
panic(badUplo)
|
||||
}
|
||||
if tA != blas.Trans && tA != blas.NoTrans && tA != blas.ConjTrans {
|
||||
panic(badTranspose)
|
||||
}
|
||||
if n < 0 {
|
||||
panic(nLT0)
|
||||
}
|
||||
if k < 0 {
|
||||
panic(kLT0)
|
||||
}
|
||||
row, col := k, n
|
||||
if tA == blas.NoTrans {
|
||||
row, col = n, k
|
||||
}
|
||||
if lda < max(1, col) {
|
||||
panic(badLdA)
|
||||
}
|
||||
if ldb < max(1, col) {
|
||||
panic(badLdB)
|
||||
}
|
||||
if ldc < max(1, n) {
|
||||
panic(badLdC)
|
||||
}
|
||||
|
||||
// Quick return if possible.
|
||||
if n == 0 {
|
||||
return
|
||||
}
|
||||
|
||||
// For zero matrix size the following slice length checks are trivially satisfied.
|
||||
if len(a) < lda*(row-1)+col {
|
||||
panic(shortA)
|
||||
}
|
||||
if len(b) < ldb*(row-1)+col {
|
||||
panic(shortB)
|
||||
}
|
||||
if len(c) < ldc*(n-1)+n {
|
||||
panic(shortC)
|
||||
}
|
||||
|
||||
if alpha == 0 {
|
||||
if beta == 0 {
|
||||
if ul == blas.Upper {
|
||||
for i := 0; i < n; i++ {
|
||||
ctmp := c[i*ldc+i : i*ldc+n]
|
||||
for j := range ctmp {
|
||||
ctmp[j] = 0
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
for i := 0; i < n; i++ {
|
||||
ctmp := c[i*ldc : i*ldc+i+1]
|
||||
for j := range ctmp {
|
||||
ctmp[j] = 0
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
if ul == blas.Upper {
|
||||
for i := 0; i < n; i++ {
|
||||
ctmp := c[i*ldc+i : i*ldc+n]
|
||||
for j := range ctmp {
|
||||
ctmp[j] *= beta
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
for i := 0; i < n; i++ {
|
||||
ctmp := c[i*ldc : i*ldc+i+1]
|
||||
for j := range ctmp {
|
||||
ctmp[j] *= beta
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
if tA == blas.NoTrans {
|
||||
if ul == blas.Upper {
|
||||
for i := 0; i < n; i++ {
|
||||
atmp := a[i*lda : i*lda+k]
|
||||
btmp := b[i*ldb : i*ldb+k]
|
||||
ctmp := c[i*ldc+i : i*ldc+n]
|
||||
for jc := range ctmp {
|
||||
j := i + jc
|
||||
var tmp1, tmp2 float32
|
||||
binner := b[j*ldb : j*ldb+k]
|
||||
for l, v := range a[j*lda : j*lda+k] {
|
||||
tmp1 += v * btmp[l]
|
||||
tmp2 += atmp[l] * binner[l]
|
||||
}
|
||||
ctmp[jc] *= beta
|
||||
ctmp[jc] += alpha * (tmp1 + tmp2)
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
for i := 0; i < n; i++ {
|
||||
atmp := a[i*lda : i*lda+k]
|
||||
btmp := b[i*ldb : i*ldb+k]
|
||||
ctmp := c[i*ldc : i*ldc+i+1]
|
||||
for j := 0; j <= i; j++ {
|
||||
var tmp1, tmp2 float32
|
||||
binner := b[j*ldb : j*ldb+k]
|
||||
for l, v := range a[j*lda : j*lda+k] {
|
||||
tmp1 += v * btmp[l]
|
||||
tmp2 += atmp[l] * binner[l]
|
||||
}
|
||||
ctmp[j] *= beta
|
||||
ctmp[j] += alpha * (tmp1 + tmp2)
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
if ul == blas.Upper {
|
||||
for i := 0; i < n; i++ {
|
||||
ctmp := c[i*ldc+i : i*ldc+n]
|
||||
if beta != 1 {
|
||||
for j := range ctmp {
|
||||
ctmp[j] *= beta
|
||||
}
|
||||
}
|
||||
for l := 0; l < k; l++ {
|
||||
tmp1 := alpha * b[l*ldb+i]
|
||||
tmp2 := alpha * a[l*lda+i]
|
||||
btmp := b[l*ldb+i : l*ldb+n]
|
||||
if tmp1 != 0 || tmp2 != 0 {
|
||||
for j, v := range a[l*lda+i : l*lda+n] {
|
||||
ctmp[j] += v*tmp1 + btmp[j]*tmp2
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
for i := 0; i < n; i++ {
|
||||
ctmp := c[i*ldc : i*ldc+i+1]
|
||||
if beta != 1 {
|
||||
for j := range ctmp {
|
||||
ctmp[j] *= beta
|
||||
}
|
||||
}
|
||||
for l := 0; l < k; l++ {
|
||||
tmp1 := alpha * b[l*ldb+i]
|
||||
tmp2 := alpha * a[l*lda+i]
|
||||
btmp := b[l*ldb : l*ldb+i+1]
|
||||
if tmp1 != 0 || tmp2 != 0 {
|
||||
for j, v := range a[l*lda : l*lda+i+1] {
|
||||
ctmp[j] += v*tmp1 + btmp[j]*tmp2
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Strmm performs one of the matrix-matrix operations
|
||||
// B = alpha * A * B if tA == blas.NoTrans and side == blas.Left
|
||||
// B = alpha * A^T * B if tA == blas.Trans or blas.ConjTrans, and side == blas.Left
|
||||
// B = alpha * B * A if tA == blas.NoTrans and side == blas.Right
|
||||
// B = alpha * B * A^T if tA == blas.Trans or blas.ConjTrans, and side == blas.Right
|
||||
// where A is an n×n or m×m triangular matrix, B is an m×n matrix, and alpha is a scalar.
|
||||
//
|
||||
// Float32 implementations are autogenerated and not directly tested.
|
||||
func (Implementation) Strmm(s blas.Side, ul blas.Uplo, tA blas.Transpose, d blas.Diag, m, n int, alpha float32, a []float32, lda int, b []float32, ldb int) {
|
||||
if s != blas.Left && s != blas.Right {
|
||||
panic(badSide)
|
||||
}
|
||||
if ul != blas.Lower && ul != blas.Upper {
|
||||
panic(badUplo)
|
||||
}
|
||||
if tA != blas.NoTrans && tA != blas.Trans && tA != blas.ConjTrans {
|
||||
panic(badTranspose)
|
||||
}
|
||||
if d != blas.NonUnit && d != blas.Unit {
|
||||
panic(badDiag)
|
||||
}
|
||||
if m < 0 {
|
||||
panic(mLT0)
|
||||
}
|
||||
if n < 0 {
|
||||
panic(nLT0)
|
||||
}
|
||||
k := n
|
||||
if s == blas.Left {
|
||||
k = m
|
||||
}
|
||||
if lda < max(1, k) {
|
||||
panic(badLdA)
|
||||
}
|
||||
if ldb < max(1, n) {
|
||||
panic(badLdB)
|
||||
}
|
||||
|
||||
// Quick return if possible.
|
||||
if m == 0 || n == 0 {
|
||||
return
|
||||
}
|
||||
|
||||
// For zero matrix size the following slice length checks are trivially satisfied.
|
||||
if len(a) < lda*(k-1)+k {
|
||||
panic(shortA)
|
||||
}
|
||||
if len(b) < ldb*(m-1)+n {
|
||||
panic(shortB)
|
||||
}
|
||||
|
||||
if alpha == 0 {
|
||||
for i := 0; i < m; i++ {
|
||||
btmp := b[i*ldb : i*ldb+n]
|
||||
for j := range btmp {
|
||||
btmp[j] = 0
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
nonUnit := d == blas.NonUnit
|
||||
if s == blas.Left {
|
||||
if tA == blas.NoTrans {
|
||||
if ul == blas.Upper {
|
||||
for i := 0; i < m; i++ {
|
||||
tmp := alpha
|
||||
if nonUnit {
|
||||
tmp *= a[i*lda+i]
|
||||
}
|
||||
btmp := b[i*ldb : i*ldb+n]
|
||||
f32.ScalUnitary(tmp, btmp)
|
||||
for ka, va := range a[i*lda+i+1 : i*lda+m] {
|
||||
k := ka + i + 1
|
||||
if va != 0 {
|
||||
f32.AxpyUnitary(alpha*va, b[k*ldb:k*ldb+n], btmp)
|
||||
}
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
for i := m - 1; i >= 0; i-- {
|
||||
tmp := alpha
|
||||
if nonUnit {
|
||||
tmp *= a[i*lda+i]
|
||||
}
|
||||
btmp := b[i*ldb : i*ldb+n]
|
||||
f32.ScalUnitary(tmp, btmp)
|
||||
for k, va := range a[i*lda : i*lda+i] {
|
||||
if va != 0 {
|
||||
f32.AxpyUnitary(alpha*va, b[k*ldb:k*ldb+n], btmp)
|
||||
}
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
// Cases where a is transposed.
|
||||
if ul == blas.Upper {
|
||||
for k := m - 1; k >= 0; k-- {
|
||||
btmpk := b[k*ldb : k*ldb+n]
|
||||
for ia, va := range a[k*lda+k+1 : k*lda+m] {
|
||||
i := ia + k + 1
|
||||
btmp := b[i*ldb : i*ldb+n]
|
||||
if va != 0 {
|
||||
f32.AxpyUnitary(alpha*va, btmpk, btmp)
|
||||
}
|
||||
}
|
||||
tmp := alpha
|
||||
if nonUnit {
|
||||
tmp *= a[k*lda+k]
|
||||
}
|
||||
if tmp != 1 {
|
||||
f32.ScalUnitary(tmp, btmpk)
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
for k := 0; k < m; k++ {
|
||||
btmpk := b[k*ldb : k*ldb+n]
|
||||
for i, va := range a[k*lda : k*lda+k] {
|
||||
btmp := b[i*ldb : i*ldb+n]
|
||||
if va != 0 {
|
||||
f32.AxpyUnitary(alpha*va, btmpk, btmp)
|
||||
}
|
||||
}
|
||||
tmp := alpha
|
||||
if nonUnit {
|
||||
tmp *= a[k*lda+k]
|
||||
}
|
||||
if tmp != 1 {
|
||||
f32.ScalUnitary(tmp, btmpk)
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
// Cases where a is on the right
|
||||
if tA == blas.NoTrans {
|
||||
if ul == blas.Upper {
|
||||
for i := 0; i < m; i++ {
|
||||
btmp := b[i*ldb : i*ldb+n]
|
||||
for k := n - 1; k >= 0; k-- {
|
||||
tmp := alpha * btmp[k]
|
||||
if tmp == 0 {
|
||||
continue
|
||||
}
|
||||
btmp[k] = tmp
|
||||
if nonUnit {
|
||||
btmp[k] *= a[k*lda+k]
|
||||
}
|
||||
f32.AxpyUnitary(tmp, a[k*lda+k+1:k*lda+n], btmp[k+1:n])
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
for i := 0; i < m; i++ {
|
||||
btmp := b[i*ldb : i*ldb+n]
|
||||
for k := 0; k < n; k++ {
|
||||
tmp := alpha * btmp[k]
|
||||
if tmp == 0 {
|
||||
continue
|
||||
}
|
||||
btmp[k] = tmp
|
||||
if nonUnit {
|
||||
btmp[k] *= a[k*lda+k]
|
||||
}
|
||||
f32.AxpyUnitary(tmp, a[k*lda:k*lda+k], btmp[:k])
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
// Cases where a is transposed.
|
||||
if ul == blas.Upper {
|
||||
for i := 0; i < m; i++ {
|
||||
btmp := b[i*ldb : i*ldb+n]
|
||||
for j, vb := range btmp {
|
||||
tmp := vb
|
||||
if nonUnit {
|
||||
tmp *= a[j*lda+j]
|
||||
}
|
||||
tmp += f32.DotUnitary(a[j*lda+j+1:j*lda+n], btmp[j+1:n])
|
||||
btmp[j] = alpha * tmp
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
for i := 0; i < m; i++ {
|
||||
btmp := b[i*ldb : i*ldb+n]
|
||||
for j := n - 1; j >= 0; j-- {
|
||||
tmp := btmp[j]
|
||||
if nonUnit {
|
||||
tmp *= a[j*lda+j]
|
||||
}
|
||||
tmp += f32.DotUnitary(a[j*lda:j*lda+j], btmp[:j])
|
||||
btmp[j] = alpha * tmp
|
||||
}
|
||||
}
|
||||
}
|
||||
864
vendor/gonum.org/v1/gonum/blas/gonum/level3float64.go
generated
vendored
Normal file
864
vendor/gonum.org/v1/gonum/blas/gonum/level3float64.go
generated
vendored
Normal file
@@ -0,0 +1,864 @@
|
||||
// Copyright ©2014 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package gonum
|
||||
|
||||
import (
|
||||
"gonum.org/v1/gonum/blas"
|
||||
"gonum.org/v1/gonum/internal/asm/f64"
|
||||
)
|
||||
|
||||
var _ blas.Float64Level3 = Implementation{}
|
||||
|
||||
// Dtrsm solves one of the matrix equations
|
||||
// A * X = alpha * B if tA == blas.NoTrans and side == blas.Left
|
||||
// A^T * X = alpha * B if tA == blas.Trans or blas.ConjTrans, and side == blas.Left
|
||||
// X * A = alpha * B if tA == blas.NoTrans and side == blas.Right
|
||||
// X * A^T = alpha * B if tA == blas.Trans or blas.ConjTrans, and side == blas.Right
|
||||
// where A is an n×n or m×m triangular matrix, X and B are m×n matrices, and alpha is a
|
||||
// scalar.
|
||||
//
|
||||
// At entry to the function, X contains the values of B, and the result is
|
||||
// stored in-place into X.
|
||||
//
|
||||
// No check is made that A is invertible.
|
||||
func (Implementation) Dtrsm(s blas.Side, ul blas.Uplo, tA blas.Transpose, d blas.Diag, m, n int, alpha float64, a []float64, lda int, b []float64, ldb int) {
|
||||
if s != blas.Left && s != blas.Right {
|
||||
panic(badSide)
|
||||
}
|
||||
if ul != blas.Lower && ul != blas.Upper {
|
||||
panic(badUplo)
|
||||
}
|
||||
if tA != blas.NoTrans && tA != blas.Trans && tA != blas.ConjTrans {
|
||||
panic(badTranspose)
|
||||
}
|
||||
if d != blas.NonUnit && d != blas.Unit {
|
||||
panic(badDiag)
|
||||
}
|
||||
if m < 0 {
|
||||
panic(mLT0)
|
||||
}
|
||||
if n < 0 {
|
||||
panic(nLT0)
|
||||
}
|
||||
k := n
|
||||
if s == blas.Left {
|
||||
k = m
|
||||
}
|
||||
if lda < max(1, k) {
|
||||
panic(badLdA)
|
||||
}
|
||||
if ldb < max(1, n) {
|
||||
panic(badLdB)
|
||||
}
|
||||
|
||||
// Quick return if possible.
|
||||
if m == 0 || n == 0 {
|
||||
return
|
||||
}
|
||||
|
||||
// For zero matrix size the following slice length checks are trivially satisfied.
|
||||
if len(a) < lda*(k-1)+k {
|
||||
panic(shortA)
|
||||
}
|
||||
if len(b) < ldb*(m-1)+n {
|
||||
panic(shortB)
|
||||
}
|
||||
|
||||
if alpha == 0 {
|
||||
for i := 0; i < m; i++ {
|
||||
btmp := b[i*ldb : i*ldb+n]
|
||||
for j := range btmp {
|
||||
btmp[j] = 0
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
nonUnit := d == blas.NonUnit
|
||||
if s == blas.Left {
|
||||
if tA == blas.NoTrans {
|
||||
if ul == blas.Upper {
|
||||
for i := m - 1; i >= 0; i-- {
|
||||
btmp := b[i*ldb : i*ldb+n]
|
||||
if alpha != 1 {
|
||||
f64.ScalUnitary(alpha, btmp)
|
||||
}
|
||||
for ka, va := range a[i*lda+i+1 : i*lda+m] {
|
||||
if va != 0 {
|
||||
k := ka + i + 1
|
||||
f64.AxpyUnitary(-va, b[k*ldb:k*ldb+n], btmp)
|
||||
}
|
||||
}
|
||||
if nonUnit {
|
||||
tmp := 1 / a[i*lda+i]
|
||||
f64.ScalUnitary(tmp, btmp)
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
for i := 0; i < m; i++ {
|
||||
btmp := b[i*ldb : i*ldb+n]
|
||||
if alpha != 1 {
|
||||
f64.ScalUnitary(alpha, btmp)
|
||||
}
|
||||
for k, va := range a[i*lda : i*lda+i] {
|
||||
if va != 0 {
|
||||
f64.AxpyUnitary(-va, b[k*ldb:k*ldb+n], btmp)
|
||||
}
|
||||
}
|
||||
if nonUnit {
|
||||
tmp := 1 / a[i*lda+i]
|
||||
f64.ScalUnitary(tmp, btmp)
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
// Cases where a is transposed
|
||||
if ul == blas.Upper {
|
||||
for k := 0; k < m; k++ {
|
||||
btmpk := b[k*ldb : k*ldb+n]
|
||||
if nonUnit {
|
||||
tmp := 1 / a[k*lda+k]
|
||||
f64.ScalUnitary(tmp, btmpk)
|
||||
}
|
||||
for ia, va := range a[k*lda+k+1 : k*lda+m] {
|
||||
if va != 0 {
|
||||
i := ia + k + 1
|
||||
f64.AxpyUnitary(-va, btmpk, b[i*ldb:i*ldb+n])
|
||||
}
|
||||
}
|
||||
if alpha != 1 {
|
||||
f64.ScalUnitary(alpha, btmpk)
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
for k := m - 1; k >= 0; k-- {
|
||||
btmpk := b[k*ldb : k*ldb+n]
|
||||
if nonUnit {
|
||||
tmp := 1 / a[k*lda+k]
|
||||
f64.ScalUnitary(tmp, btmpk)
|
||||
}
|
||||
for i, va := range a[k*lda : k*lda+k] {
|
||||
if va != 0 {
|
||||
f64.AxpyUnitary(-va, btmpk, b[i*ldb:i*ldb+n])
|
||||
}
|
||||
}
|
||||
if alpha != 1 {
|
||||
f64.ScalUnitary(alpha, btmpk)
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
// Cases where a is to the right of X.
|
||||
if tA == blas.NoTrans {
|
||||
if ul == blas.Upper {
|
||||
for i := 0; i < m; i++ {
|
||||
btmp := b[i*ldb : i*ldb+n]
|
||||
if alpha != 1 {
|
||||
f64.ScalUnitary(alpha, btmp)
|
||||
}
|
||||
for k, vb := range btmp {
|
||||
if vb == 0 {
|
||||
continue
|
||||
}
|
||||
if nonUnit {
|
||||
btmp[k] /= a[k*lda+k]
|
||||
}
|
||||
f64.AxpyUnitary(-btmp[k], a[k*lda+k+1:k*lda+n], btmp[k+1:n])
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
for i := 0; i < m; i++ {
|
||||
btmp := b[i*ldb : i*ldb+n]
|
||||
if alpha != 1 {
|
||||
f64.ScalUnitary(alpha, btmp)
|
||||
}
|
||||
for k := n - 1; k >= 0; k-- {
|
||||
if btmp[k] == 0 {
|
||||
continue
|
||||
}
|
||||
if nonUnit {
|
||||
btmp[k] /= a[k*lda+k]
|
||||
}
|
||||
f64.AxpyUnitary(-btmp[k], a[k*lda:k*lda+k], btmp[:k])
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
// Cases where a is transposed.
|
||||
if ul == blas.Upper {
|
||||
for i := 0; i < m; i++ {
|
||||
btmp := b[i*ldb : i*ldb+n]
|
||||
for j := n - 1; j >= 0; j-- {
|
||||
tmp := alpha*btmp[j] - f64.DotUnitary(a[j*lda+j+1:j*lda+n], btmp[j+1:])
|
||||
if nonUnit {
|
||||
tmp /= a[j*lda+j]
|
||||
}
|
||||
btmp[j] = tmp
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
for i := 0; i < m; i++ {
|
||||
btmp := b[i*ldb : i*ldb+n]
|
||||
for j := 0; j < n; j++ {
|
||||
tmp := alpha*btmp[j] - f64.DotUnitary(a[j*lda:j*lda+j], btmp[:j])
|
||||
if nonUnit {
|
||||
tmp /= a[j*lda+j]
|
||||
}
|
||||
btmp[j] = tmp
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Dsymm performs one of the matrix-matrix operations
|
||||
// C = alpha * A * B + beta * C if side == blas.Left
|
||||
// C = alpha * B * A + beta * C if side == blas.Right
|
||||
// where A is an n×n or m×m symmetric matrix, B and C are m×n matrices, and alpha
|
||||
// is a scalar.
|
||||
func (Implementation) Dsymm(s blas.Side, ul blas.Uplo, m, n int, alpha float64, a []float64, lda int, b []float64, ldb int, beta float64, c []float64, ldc int) {
|
||||
if s != blas.Right && s != blas.Left {
|
||||
panic(badSide)
|
||||
}
|
||||
if ul != blas.Lower && ul != blas.Upper {
|
||||
panic(badUplo)
|
||||
}
|
||||
if m < 0 {
|
||||
panic(mLT0)
|
||||
}
|
||||
if n < 0 {
|
||||
panic(nLT0)
|
||||
}
|
||||
k := n
|
||||
if s == blas.Left {
|
||||
k = m
|
||||
}
|
||||
if lda < max(1, k) {
|
||||
panic(badLdA)
|
||||
}
|
||||
if ldb < max(1, n) {
|
||||
panic(badLdB)
|
||||
}
|
||||
if ldc < max(1, n) {
|
||||
panic(badLdC)
|
||||
}
|
||||
|
||||
// Quick return if possible.
|
||||
if m == 0 || n == 0 {
|
||||
return
|
||||
}
|
||||
|
||||
// For zero matrix size the following slice length checks are trivially satisfied.
|
||||
if len(a) < lda*(k-1)+k {
|
||||
panic(shortA)
|
||||
}
|
||||
if len(b) < ldb*(m-1)+n {
|
||||
panic(shortB)
|
||||
}
|
||||
if len(c) < ldc*(m-1)+n {
|
||||
panic(shortC)
|
||||
}
|
||||
|
||||
// Quick return if possible.
|
||||
if alpha == 0 && beta == 1 {
|
||||
return
|
||||
}
|
||||
|
||||
if alpha == 0 {
|
||||
if beta == 0 {
|
||||
for i := 0; i < m; i++ {
|
||||
ctmp := c[i*ldc : i*ldc+n]
|
||||
for j := range ctmp {
|
||||
ctmp[j] = 0
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
for i := 0; i < m; i++ {
|
||||
ctmp := c[i*ldc : i*ldc+n]
|
||||
for j := 0; j < n; j++ {
|
||||
ctmp[j] *= beta
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
isUpper := ul == blas.Upper
|
||||
if s == blas.Left {
|
||||
for i := 0; i < m; i++ {
|
||||
atmp := alpha * a[i*lda+i]
|
||||
btmp := b[i*ldb : i*ldb+n]
|
||||
ctmp := c[i*ldc : i*ldc+n]
|
||||
for j, v := range btmp {
|
||||
ctmp[j] *= beta
|
||||
ctmp[j] += atmp * v
|
||||
}
|
||||
|
||||
for k := 0; k < i; k++ {
|
||||
var atmp float64
|
||||
if isUpper {
|
||||
atmp = a[k*lda+i]
|
||||
} else {
|
||||
atmp = a[i*lda+k]
|
||||
}
|
||||
atmp *= alpha
|
||||
f64.AxpyUnitary(atmp, b[k*ldb:k*ldb+n], ctmp)
|
||||
}
|
||||
for k := i + 1; k < m; k++ {
|
||||
var atmp float64
|
||||
if isUpper {
|
||||
atmp = a[i*lda+k]
|
||||
} else {
|
||||
atmp = a[k*lda+i]
|
||||
}
|
||||
atmp *= alpha
|
||||
f64.AxpyUnitary(atmp, b[k*ldb:k*ldb+n], ctmp)
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
if isUpper {
|
||||
for i := 0; i < m; i++ {
|
||||
for j := n - 1; j >= 0; j-- {
|
||||
tmp := alpha * b[i*ldb+j]
|
||||
var tmp2 float64
|
||||
atmp := a[j*lda+j+1 : j*lda+n]
|
||||
btmp := b[i*ldb+j+1 : i*ldb+n]
|
||||
ctmp := c[i*ldc+j+1 : i*ldc+n]
|
||||
for k, v := range atmp {
|
||||
ctmp[k] += tmp * v
|
||||
tmp2 += btmp[k] * v
|
||||
}
|
||||
c[i*ldc+j] *= beta
|
||||
c[i*ldc+j] += tmp*a[j*lda+j] + alpha*tmp2
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
for i := 0; i < m; i++ {
|
||||
for j := 0; j < n; j++ {
|
||||
tmp := alpha * b[i*ldb+j]
|
||||
var tmp2 float64
|
||||
atmp := a[j*lda : j*lda+j]
|
||||
btmp := b[i*ldb : i*ldb+j]
|
||||
ctmp := c[i*ldc : i*ldc+j]
|
||||
for k, v := range atmp {
|
||||
ctmp[k] += tmp * v
|
||||
tmp2 += btmp[k] * v
|
||||
}
|
||||
c[i*ldc+j] *= beta
|
||||
c[i*ldc+j] += tmp*a[j*lda+j] + alpha*tmp2
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Dsyrk performs one of the symmetric rank-k operations
|
||||
// C = alpha * A * A^T + beta * C if tA == blas.NoTrans
|
||||
// C = alpha * A^T * A + beta * C if tA == blas.Trans or tA == blas.ConjTrans
|
||||
// where A is an n×k or k×n matrix, C is an n×n symmetric matrix, and alpha and
|
||||
// beta are scalars.
|
||||
func (Implementation) Dsyrk(ul blas.Uplo, tA blas.Transpose, n, k int, alpha float64, a []float64, lda int, beta float64, c []float64, ldc int) {
|
||||
if ul != blas.Lower && ul != blas.Upper {
|
||||
panic(badUplo)
|
||||
}
|
||||
if tA != blas.Trans && tA != blas.NoTrans && tA != blas.ConjTrans {
|
||||
panic(badTranspose)
|
||||
}
|
||||
if n < 0 {
|
||||
panic(nLT0)
|
||||
}
|
||||
if k < 0 {
|
||||
panic(kLT0)
|
||||
}
|
||||
row, col := k, n
|
||||
if tA == blas.NoTrans {
|
||||
row, col = n, k
|
||||
}
|
||||
if lda < max(1, col) {
|
||||
panic(badLdA)
|
||||
}
|
||||
if ldc < max(1, n) {
|
||||
panic(badLdC)
|
||||
}
|
||||
|
||||
// Quick return if possible.
|
||||
if n == 0 {
|
||||
return
|
||||
}
|
||||
|
||||
// For zero matrix size the following slice length checks are trivially satisfied.
|
||||
if len(a) < lda*(row-1)+col {
|
||||
panic(shortA)
|
||||
}
|
||||
if len(c) < ldc*(n-1)+n {
|
||||
panic(shortC)
|
||||
}
|
||||
|
||||
if alpha == 0 {
|
||||
if beta == 0 {
|
||||
if ul == blas.Upper {
|
||||
for i := 0; i < n; i++ {
|
||||
ctmp := c[i*ldc+i : i*ldc+n]
|
||||
for j := range ctmp {
|
||||
ctmp[j] = 0
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
for i := 0; i < n; i++ {
|
||||
ctmp := c[i*ldc : i*ldc+i+1]
|
||||
for j := range ctmp {
|
||||
ctmp[j] = 0
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
if ul == blas.Upper {
|
||||
for i := 0; i < n; i++ {
|
||||
ctmp := c[i*ldc+i : i*ldc+n]
|
||||
for j := range ctmp {
|
||||
ctmp[j] *= beta
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
for i := 0; i < n; i++ {
|
||||
ctmp := c[i*ldc : i*ldc+i+1]
|
||||
for j := range ctmp {
|
||||
ctmp[j] *= beta
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
if tA == blas.NoTrans {
|
||||
if ul == blas.Upper {
|
||||
for i := 0; i < n; i++ {
|
||||
ctmp := c[i*ldc+i : i*ldc+n]
|
||||
atmp := a[i*lda : i*lda+k]
|
||||
if beta == 0 {
|
||||
for jc := range ctmp {
|
||||
j := jc + i
|
||||
ctmp[jc] = alpha * f64.DotUnitary(atmp, a[j*lda:j*lda+k])
|
||||
}
|
||||
} else {
|
||||
for jc, vc := range ctmp {
|
||||
j := jc + i
|
||||
ctmp[jc] = vc*beta + alpha*f64.DotUnitary(atmp, a[j*lda:j*lda+k])
|
||||
}
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
for i := 0; i < n; i++ {
|
||||
ctmp := c[i*ldc : i*ldc+i+1]
|
||||
atmp := a[i*lda : i*lda+k]
|
||||
if beta == 0 {
|
||||
for j := range ctmp {
|
||||
ctmp[j] = alpha * f64.DotUnitary(a[j*lda:j*lda+k], atmp)
|
||||
}
|
||||
} else {
|
||||
for j, vc := range ctmp {
|
||||
ctmp[j] = vc*beta + alpha*f64.DotUnitary(a[j*lda:j*lda+k], atmp)
|
||||
}
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
// Cases where a is transposed.
|
||||
if ul == blas.Upper {
|
||||
for i := 0; i < n; i++ {
|
||||
ctmp := c[i*ldc+i : i*ldc+n]
|
||||
if beta == 0 {
|
||||
for j := range ctmp {
|
||||
ctmp[j] = 0
|
||||
}
|
||||
} else if beta != 1 {
|
||||
for j := range ctmp {
|
||||
ctmp[j] *= beta
|
||||
}
|
||||
}
|
||||
for l := 0; l < k; l++ {
|
||||
tmp := alpha * a[l*lda+i]
|
||||
if tmp != 0 {
|
||||
f64.AxpyUnitary(tmp, a[l*lda+i:l*lda+n], ctmp)
|
||||
}
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
for i := 0; i < n; i++ {
|
||||
ctmp := c[i*ldc : i*ldc+i+1]
|
||||
if beta != 1 {
|
||||
for j := range ctmp {
|
||||
ctmp[j] *= beta
|
||||
}
|
||||
}
|
||||
for l := 0; l < k; l++ {
|
||||
tmp := alpha * a[l*lda+i]
|
||||
if tmp != 0 {
|
||||
f64.AxpyUnitary(tmp, a[l*lda:l*lda+i+1], ctmp)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Dsyr2k performs one of the symmetric rank 2k operations
|
||||
// C = alpha * A * B^T + alpha * B * A^T + beta * C if tA == blas.NoTrans
|
||||
// C = alpha * A^T * B + alpha * B^T * A + beta * C if tA == blas.Trans or tA == blas.ConjTrans
|
||||
// where A and B are n×k or k×n matrices, C is an n×n symmetric matrix, and
|
||||
// alpha and beta are scalars.
|
||||
func (Implementation) Dsyr2k(ul blas.Uplo, tA blas.Transpose, n, k int, alpha float64, a []float64, lda int, b []float64, ldb int, beta float64, c []float64, ldc int) {
|
||||
if ul != blas.Lower && ul != blas.Upper {
|
||||
panic(badUplo)
|
||||
}
|
||||
if tA != blas.Trans && tA != blas.NoTrans && tA != blas.ConjTrans {
|
||||
panic(badTranspose)
|
||||
}
|
||||
if n < 0 {
|
||||
panic(nLT0)
|
||||
}
|
||||
if k < 0 {
|
||||
panic(kLT0)
|
||||
}
|
||||
row, col := k, n
|
||||
if tA == blas.NoTrans {
|
||||
row, col = n, k
|
||||
}
|
||||
if lda < max(1, col) {
|
||||
panic(badLdA)
|
||||
}
|
||||
if ldb < max(1, col) {
|
||||
panic(badLdB)
|
||||
}
|
||||
if ldc < max(1, n) {
|
||||
panic(badLdC)
|
||||
}
|
||||
|
||||
// Quick return if possible.
|
||||
if n == 0 {
|
||||
return
|
||||
}
|
||||
|
||||
// For zero matrix size the following slice length checks are trivially satisfied.
|
||||
if len(a) < lda*(row-1)+col {
|
||||
panic(shortA)
|
||||
}
|
||||
if len(b) < ldb*(row-1)+col {
|
||||
panic(shortB)
|
||||
}
|
||||
if len(c) < ldc*(n-1)+n {
|
||||
panic(shortC)
|
||||
}
|
||||
|
||||
if alpha == 0 {
|
||||
if beta == 0 {
|
||||
if ul == blas.Upper {
|
||||
for i := 0; i < n; i++ {
|
||||
ctmp := c[i*ldc+i : i*ldc+n]
|
||||
for j := range ctmp {
|
||||
ctmp[j] = 0
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
for i := 0; i < n; i++ {
|
||||
ctmp := c[i*ldc : i*ldc+i+1]
|
||||
for j := range ctmp {
|
||||
ctmp[j] = 0
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
if ul == blas.Upper {
|
||||
for i := 0; i < n; i++ {
|
||||
ctmp := c[i*ldc+i : i*ldc+n]
|
||||
for j := range ctmp {
|
||||
ctmp[j] *= beta
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
for i := 0; i < n; i++ {
|
||||
ctmp := c[i*ldc : i*ldc+i+1]
|
||||
for j := range ctmp {
|
||||
ctmp[j] *= beta
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
if tA == blas.NoTrans {
|
||||
if ul == blas.Upper {
|
||||
for i := 0; i < n; i++ {
|
||||
atmp := a[i*lda : i*lda+k]
|
||||
btmp := b[i*ldb : i*ldb+k]
|
||||
ctmp := c[i*ldc+i : i*ldc+n]
|
||||
for jc := range ctmp {
|
||||
j := i + jc
|
||||
var tmp1, tmp2 float64
|
||||
binner := b[j*ldb : j*ldb+k]
|
||||
for l, v := range a[j*lda : j*lda+k] {
|
||||
tmp1 += v * btmp[l]
|
||||
tmp2 += atmp[l] * binner[l]
|
||||
}
|
||||
ctmp[jc] *= beta
|
||||
ctmp[jc] += alpha * (tmp1 + tmp2)
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
for i := 0; i < n; i++ {
|
||||
atmp := a[i*lda : i*lda+k]
|
||||
btmp := b[i*ldb : i*ldb+k]
|
||||
ctmp := c[i*ldc : i*ldc+i+1]
|
||||
for j := 0; j <= i; j++ {
|
||||
var tmp1, tmp2 float64
|
||||
binner := b[j*ldb : j*ldb+k]
|
||||
for l, v := range a[j*lda : j*lda+k] {
|
||||
tmp1 += v * btmp[l]
|
||||
tmp2 += atmp[l] * binner[l]
|
||||
}
|
||||
ctmp[j] *= beta
|
||||
ctmp[j] += alpha * (tmp1 + tmp2)
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
if ul == blas.Upper {
|
||||
for i := 0; i < n; i++ {
|
||||
ctmp := c[i*ldc+i : i*ldc+n]
|
||||
if beta != 1 {
|
||||
for j := range ctmp {
|
||||
ctmp[j] *= beta
|
||||
}
|
||||
}
|
||||
for l := 0; l < k; l++ {
|
||||
tmp1 := alpha * b[l*ldb+i]
|
||||
tmp2 := alpha * a[l*lda+i]
|
||||
btmp := b[l*ldb+i : l*ldb+n]
|
||||
if tmp1 != 0 || tmp2 != 0 {
|
||||
for j, v := range a[l*lda+i : l*lda+n] {
|
||||
ctmp[j] += v*tmp1 + btmp[j]*tmp2
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
for i := 0; i < n; i++ {
|
||||
ctmp := c[i*ldc : i*ldc+i+1]
|
||||
if beta != 1 {
|
||||
for j := range ctmp {
|
||||
ctmp[j] *= beta
|
||||
}
|
||||
}
|
||||
for l := 0; l < k; l++ {
|
||||
tmp1 := alpha * b[l*ldb+i]
|
||||
tmp2 := alpha * a[l*lda+i]
|
||||
btmp := b[l*ldb : l*ldb+i+1]
|
||||
if tmp1 != 0 || tmp2 != 0 {
|
||||
for j, v := range a[l*lda : l*lda+i+1] {
|
||||
ctmp[j] += v*tmp1 + btmp[j]*tmp2
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Dtrmm performs one of the matrix-matrix operations
|
||||
// B = alpha * A * B if tA == blas.NoTrans and side == blas.Left
|
||||
// B = alpha * A^T * B if tA == blas.Trans or blas.ConjTrans, and side == blas.Left
|
||||
// B = alpha * B * A if tA == blas.NoTrans and side == blas.Right
|
||||
// B = alpha * B * A^T if tA == blas.Trans or blas.ConjTrans, and side == blas.Right
|
||||
// where A is an n×n or m×m triangular matrix, B is an m×n matrix, and alpha is a scalar.
|
||||
func (Implementation) Dtrmm(s blas.Side, ul blas.Uplo, tA blas.Transpose, d blas.Diag, m, n int, alpha float64, a []float64, lda int, b []float64, ldb int) {
|
||||
if s != blas.Left && s != blas.Right {
|
||||
panic(badSide)
|
||||
}
|
||||
if ul != blas.Lower && ul != blas.Upper {
|
||||
panic(badUplo)
|
||||
}
|
||||
if tA != blas.NoTrans && tA != blas.Trans && tA != blas.ConjTrans {
|
||||
panic(badTranspose)
|
||||
}
|
||||
if d != blas.NonUnit && d != blas.Unit {
|
||||
panic(badDiag)
|
||||
}
|
||||
if m < 0 {
|
||||
panic(mLT0)
|
||||
}
|
||||
if n < 0 {
|
||||
panic(nLT0)
|
||||
}
|
||||
k := n
|
||||
if s == blas.Left {
|
||||
k = m
|
||||
}
|
||||
if lda < max(1, k) {
|
||||
panic(badLdA)
|
||||
}
|
||||
if ldb < max(1, n) {
|
||||
panic(badLdB)
|
||||
}
|
||||
|
||||
// Quick return if possible.
|
||||
if m == 0 || n == 0 {
|
||||
return
|
||||
}
|
||||
|
||||
// For zero matrix size the following slice length checks are trivially satisfied.
|
||||
if len(a) < lda*(k-1)+k {
|
||||
panic(shortA)
|
||||
}
|
||||
if len(b) < ldb*(m-1)+n {
|
||||
panic(shortB)
|
||||
}
|
||||
|
||||
if alpha == 0 {
|
||||
for i := 0; i < m; i++ {
|
||||
btmp := b[i*ldb : i*ldb+n]
|
||||
for j := range btmp {
|
||||
btmp[j] = 0
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
nonUnit := d == blas.NonUnit
|
||||
if s == blas.Left {
|
||||
if tA == blas.NoTrans {
|
||||
if ul == blas.Upper {
|
||||
for i := 0; i < m; i++ {
|
||||
tmp := alpha
|
||||
if nonUnit {
|
||||
tmp *= a[i*lda+i]
|
||||
}
|
||||
btmp := b[i*ldb : i*ldb+n]
|
||||
f64.ScalUnitary(tmp, btmp)
|
||||
for ka, va := range a[i*lda+i+1 : i*lda+m] {
|
||||
k := ka + i + 1
|
||||
if va != 0 {
|
||||
f64.AxpyUnitary(alpha*va, b[k*ldb:k*ldb+n], btmp)
|
||||
}
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
for i := m - 1; i >= 0; i-- {
|
||||
tmp := alpha
|
||||
if nonUnit {
|
||||
tmp *= a[i*lda+i]
|
||||
}
|
||||
btmp := b[i*ldb : i*ldb+n]
|
||||
f64.ScalUnitary(tmp, btmp)
|
||||
for k, va := range a[i*lda : i*lda+i] {
|
||||
if va != 0 {
|
||||
f64.AxpyUnitary(alpha*va, b[k*ldb:k*ldb+n], btmp)
|
||||
}
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
// Cases where a is transposed.
|
||||
if ul == blas.Upper {
|
||||
for k := m - 1; k >= 0; k-- {
|
||||
btmpk := b[k*ldb : k*ldb+n]
|
||||
for ia, va := range a[k*lda+k+1 : k*lda+m] {
|
||||
i := ia + k + 1
|
||||
btmp := b[i*ldb : i*ldb+n]
|
||||
if va != 0 {
|
||||
f64.AxpyUnitary(alpha*va, btmpk, btmp)
|
||||
}
|
||||
}
|
||||
tmp := alpha
|
||||
if nonUnit {
|
||||
tmp *= a[k*lda+k]
|
||||
}
|
||||
if tmp != 1 {
|
||||
f64.ScalUnitary(tmp, btmpk)
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
for k := 0; k < m; k++ {
|
||||
btmpk := b[k*ldb : k*ldb+n]
|
||||
for i, va := range a[k*lda : k*lda+k] {
|
||||
btmp := b[i*ldb : i*ldb+n]
|
||||
if va != 0 {
|
||||
f64.AxpyUnitary(alpha*va, btmpk, btmp)
|
||||
}
|
||||
}
|
||||
tmp := alpha
|
||||
if nonUnit {
|
||||
tmp *= a[k*lda+k]
|
||||
}
|
||||
if tmp != 1 {
|
||||
f64.ScalUnitary(tmp, btmpk)
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
// Cases where a is on the right
|
||||
if tA == blas.NoTrans {
|
||||
if ul == blas.Upper {
|
||||
for i := 0; i < m; i++ {
|
||||
btmp := b[i*ldb : i*ldb+n]
|
||||
for k := n - 1; k >= 0; k-- {
|
||||
tmp := alpha * btmp[k]
|
||||
if tmp == 0 {
|
||||
continue
|
||||
}
|
||||
btmp[k] = tmp
|
||||
if nonUnit {
|
||||
btmp[k] *= a[k*lda+k]
|
||||
}
|
||||
f64.AxpyUnitary(tmp, a[k*lda+k+1:k*lda+n], btmp[k+1:n])
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
for i := 0; i < m; i++ {
|
||||
btmp := b[i*ldb : i*ldb+n]
|
||||
for k := 0; k < n; k++ {
|
||||
tmp := alpha * btmp[k]
|
||||
if tmp == 0 {
|
||||
continue
|
||||
}
|
||||
btmp[k] = tmp
|
||||
if nonUnit {
|
||||
btmp[k] *= a[k*lda+k]
|
||||
}
|
||||
f64.AxpyUnitary(tmp, a[k*lda:k*lda+k], btmp[:k])
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
// Cases where a is transposed.
|
||||
if ul == blas.Upper {
|
||||
for i := 0; i < m; i++ {
|
||||
btmp := b[i*ldb : i*ldb+n]
|
||||
for j, vb := range btmp {
|
||||
tmp := vb
|
||||
if nonUnit {
|
||||
tmp *= a[j*lda+j]
|
||||
}
|
||||
tmp += f64.DotUnitary(a[j*lda+j+1:j*lda+n], btmp[j+1:n])
|
||||
btmp[j] = alpha * tmp
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
for i := 0; i < m; i++ {
|
||||
btmp := b[i*ldb : i*ldb+n]
|
||||
for j := n - 1; j >= 0; j-- {
|
||||
tmp := btmp[j]
|
||||
if nonUnit {
|
||||
tmp *= a[j*lda+j]
|
||||
}
|
||||
tmp += f64.DotUnitary(a[j*lda:j*lda+j], btmp[:j])
|
||||
btmp[j] = alpha * tmp
|
||||
}
|
||||
}
|
||||
}
|
||||
318
vendor/gonum.org/v1/gonum/blas/gonum/sgemm.go
generated
vendored
Normal file
318
vendor/gonum.org/v1/gonum/blas/gonum/sgemm.go
generated
vendored
Normal file
@@ -0,0 +1,318 @@
|
||||
// Code generated by "go generate gonum.org/v1/gonum/blas/gonum”; DO NOT EDIT.
|
||||
|
||||
// Copyright ©2014 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package gonum
|
||||
|
||||
import (
|
||||
"runtime"
|
||||
"sync"
|
||||
|
||||
"gonum.org/v1/gonum/blas"
|
||||
"gonum.org/v1/gonum/internal/asm/f32"
|
||||
)
|
||||
|
||||
// Sgemm performs one of the matrix-matrix operations
|
||||
// C = alpha * A * B + beta * C
|
||||
// C = alpha * A^T * B + beta * C
|
||||
// C = alpha * A * B^T + beta * C
|
||||
// C = alpha * A^T * B^T + beta * C
|
||||
// where A is an m×k or k×m dense matrix, B is an n×k or k×n dense matrix, C is
|
||||
// an m×n matrix, and alpha and beta are scalars. tA and tB specify whether A or
|
||||
// B are transposed.
|
||||
//
|
||||
// Float32 implementations are autogenerated and not directly tested.
|
||||
func (Implementation) Sgemm(tA, tB blas.Transpose, m, n, k int, alpha float32, a []float32, lda int, b []float32, ldb int, beta float32, c []float32, ldc int) {
|
||||
switch tA {
|
||||
default:
|
||||
panic(badTranspose)
|
||||
case blas.NoTrans, blas.Trans, blas.ConjTrans:
|
||||
}
|
||||
switch tB {
|
||||
default:
|
||||
panic(badTranspose)
|
||||
case blas.NoTrans, blas.Trans, blas.ConjTrans:
|
||||
}
|
||||
if m < 0 {
|
||||
panic(mLT0)
|
||||
}
|
||||
if n < 0 {
|
||||
panic(nLT0)
|
||||
}
|
||||
if k < 0 {
|
||||
panic(kLT0)
|
||||
}
|
||||
aTrans := tA == blas.Trans || tA == blas.ConjTrans
|
||||
if aTrans {
|
||||
if lda < max(1, m) {
|
||||
panic(badLdA)
|
||||
}
|
||||
} else {
|
||||
if lda < max(1, k) {
|
||||
panic(badLdA)
|
||||
}
|
||||
}
|
||||
bTrans := tB == blas.Trans || tB == blas.ConjTrans
|
||||
if bTrans {
|
||||
if ldb < max(1, k) {
|
||||
panic(badLdB)
|
||||
}
|
||||
} else {
|
||||
if ldb < max(1, n) {
|
||||
panic(badLdB)
|
||||
}
|
||||
}
|
||||
if ldc < max(1, n) {
|
||||
panic(badLdC)
|
||||
}
|
||||
|
||||
// Quick return if possible.
|
||||
if m == 0 || n == 0 {
|
||||
return
|
||||
}
|
||||
|
||||
// For zero matrix size the following slice length checks are trivially satisfied.
|
||||
if aTrans {
|
||||
if len(a) < (k-1)*lda+m {
|
||||
panic(shortA)
|
||||
}
|
||||
} else {
|
||||
if len(a) < (m-1)*lda+k {
|
||||
panic(shortA)
|
||||
}
|
||||
}
|
||||
if bTrans {
|
||||
if len(b) < (n-1)*ldb+k {
|
||||
panic(shortB)
|
||||
}
|
||||
} else {
|
||||
if len(b) < (k-1)*ldb+n {
|
||||
panic(shortB)
|
||||
}
|
||||
}
|
||||
if len(c) < (m-1)*ldc+n {
|
||||
panic(shortC)
|
||||
}
|
||||
|
||||
// Quick return if possible.
|
||||
if (alpha == 0 || k == 0) && beta == 1 {
|
||||
return
|
||||
}
|
||||
|
||||
// scale c
|
||||
if beta != 1 {
|
||||
if beta == 0 {
|
||||
for i := 0; i < m; i++ {
|
||||
ctmp := c[i*ldc : i*ldc+n]
|
||||
for j := range ctmp {
|
||||
ctmp[j] = 0
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for i := 0; i < m; i++ {
|
||||
ctmp := c[i*ldc : i*ldc+n]
|
||||
for j := range ctmp {
|
||||
ctmp[j] *= beta
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
sgemmParallel(aTrans, bTrans, m, n, k, a, lda, b, ldb, c, ldc, alpha)
|
||||
}
|
||||
|
||||
func sgemmParallel(aTrans, bTrans bool, m, n, k int, a []float32, lda int, b []float32, ldb int, c []float32, ldc int, alpha float32) {
|
||||
// dgemmParallel computes a parallel matrix multiplication by partitioning
|
||||
// a and b into sub-blocks, and updating c with the multiplication of the sub-block
|
||||
// In all cases,
|
||||
// A = [ A_11 A_12 ... A_1j
|
||||
// A_21 A_22 ... A_2j
|
||||
// ...
|
||||
// A_i1 A_i2 ... A_ij]
|
||||
//
|
||||
// and same for B. All of the submatrix sizes are blockSize×blockSize except
|
||||
// at the edges.
|
||||
//
|
||||
// In all cases, there is one dimension for each matrix along which
|
||||
// C must be updated sequentially.
|
||||
// Cij = \sum_k Aik Bki, (A * B)
|
||||
// Cij = \sum_k Aki Bkj, (A^T * B)
|
||||
// Cij = \sum_k Aik Bjk, (A * B^T)
|
||||
// Cij = \sum_k Aki Bjk, (A^T * B^T)
|
||||
//
|
||||
// This code computes one {i, j} block sequentially along the k dimension,
|
||||
// and computes all of the {i, j} blocks concurrently. This
|
||||
// partitioning allows Cij to be updated in-place without race-conditions.
|
||||
// Instead of launching a goroutine for each possible concurrent computation,
|
||||
// a number of worker goroutines are created and channels are used to pass
|
||||
// available and completed cases.
|
||||
//
|
||||
// http://alexkr.com/docs/matrixmult.pdf is a good reference on matrix-matrix
|
||||
// multiplies, though this code does not copy matrices to attempt to eliminate
|
||||
// cache misses.
|
||||
|
||||
maxKLen := k
|
||||
parBlocks := blocks(m, blockSize) * blocks(n, blockSize)
|
||||
if parBlocks < minParBlock {
|
||||
// The matrix multiplication is small in the dimensions where it can be
|
||||
// computed concurrently. Just do it in serial.
|
||||
sgemmSerial(aTrans, bTrans, m, n, k, a, lda, b, ldb, c, ldc, alpha)
|
||||
return
|
||||
}
|
||||
|
||||
nWorkers := runtime.GOMAXPROCS(0)
|
||||
if parBlocks < nWorkers {
|
||||
nWorkers = parBlocks
|
||||
}
|
||||
// There is a tradeoff between the workers having to wait for work
|
||||
// and a large buffer making operations slow.
|
||||
buf := buffMul * nWorkers
|
||||
if buf > parBlocks {
|
||||
buf = parBlocks
|
||||
}
|
||||
|
||||
sendChan := make(chan subMul, buf)
|
||||
|
||||
// Launch workers. A worker receives an {i, j} submatrix of c, and computes
|
||||
// A_ik B_ki (or the transposed version) storing the result in c_ij. When the
|
||||
// channel is finally closed, it signals to the waitgroup that it has finished
|
||||
// computing.
|
||||
var wg sync.WaitGroup
|
||||
for i := 0; i < nWorkers; i++ {
|
||||
wg.Add(1)
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
for sub := range sendChan {
|
||||
i := sub.i
|
||||
j := sub.j
|
||||
leni := blockSize
|
||||
if i+leni > m {
|
||||
leni = m - i
|
||||
}
|
||||
lenj := blockSize
|
||||
if j+lenj > n {
|
||||
lenj = n - j
|
||||
}
|
||||
|
||||
cSub := sliceView32(c, ldc, i, j, leni, lenj)
|
||||
|
||||
// Compute A_ik B_kj for all k
|
||||
for k := 0; k < maxKLen; k += blockSize {
|
||||
lenk := blockSize
|
||||
if k+lenk > maxKLen {
|
||||
lenk = maxKLen - k
|
||||
}
|
||||
var aSub, bSub []float32
|
||||
if aTrans {
|
||||
aSub = sliceView32(a, lda, k, i, lenk, leni)
|
||||
} else {
|
||||
aSub = sliceView32(a, lda, i, k, leni, lenk)
|
||||
}
|
||||
if bTrans {
|
||||
bSub = sliceView32(b, ldb, j, k, lenj, lenk)
|
||||
} else {
|
||||
bSub = sliceView32(b, ldb, k, j, lenk, lenj)
|
||||
}
|
||||
sgemmSerial(aTrans, bTrans, leni, lenj, lenk, aSub, lda, bSub, ldb, cSub, ldc, alpha)
|
||||
}
|
||||
}
|
||||
}()
|
||||
}
|
||||
|
||||
// Send out all of the {i, j} subblocks for computation.
|
||||
for i := 0; i < m; i += blockSize {
|
||||
for j := 0; j < n; j += blockSize {
|
||||
sendChan <- subMul{
|
||||
i: i,
|
||||
j: j,
|
||||
}
|
||||
}
|
||||
}
|
||||
close(sendChan)
|
||||
wg.Wait()
|
||||
}
|
||||
|
||||
// sgemmSerial is serial matrix multiply
|
||||
func sgemmSerial(aTrans, bTrans bool, m, n, k int, a []float32, lda int, b []float32, ldb int, c []float32, ldc int, alpha float32) {
|
||||
switch {
|
||||
case !aTrans && !bTrans:
|
||||
sgemmSerialNotNot(m, n, k, a, lda, b, ldb, c, ldc, alpha)
|
||||
return
|
||||
case aTrans && !bTrans:
|
||||
sgemmSerialTransNot(m, n, k, a, lda, b, ldb, c, ldc, alpha)
|
||||
return
|
||||
case !aTrans && bTrans:
|
||||
sgemmSerialNotTrans(m, n, k, a, lda, b, ldb, c, ldc, alpha)
|
||||
return
|
||||
case aTrans && bTrans:
|
||||
sgemmSerialTransTrans(m, n, k, a, lda, b, ldb, c, ldc, alpha)
|
||||
return
|
||||
default:
|
||||
panic("unreachable")
|
||||
}
|
||||
}
|
||||
|
||||
// sgemmSerial where neither a nor b are transposed
|
||||
func sgemmSerialNotNot(m, n, k int, a []float32, lda int, b []float32, ldb int, c []float32, ldc int, alpha float32) {
|
||||
// This style is used instead of the literal [i*stride +j]) is used because
|
||||
// approximately 5 times faster as of go 1.3.
|
||||
for i := 0; i < m; i++ {
|
||||
ctmp := c[i*ldc : i*ldc+n]
|
||||
for l, v := range a[i*lda : i*lda+k] {
|
||||
tmp := alpha * v
|
||||
if tmp != 0 {
|
||||
f32.AxpyUnitary(tmp, b[l*ldb:l*ldb+n], ctmp)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// sgemmSerial where neither a is transposed and b is not
|
||||
func sgemmSerialTransNot(m, n, k int, a []float32, lda int, b []float32, ldb int, c []float32, ldc int, alpha float32) {
|
||||
// This style is used instead of the literal [i*stride +j]) is used because
|
||||
// approximately 5 times faster as of go 1.3.
|
||||
for l := 0; l < k; l++ {
|
||||
btmp := b[l*ldb : l*ldb+n]
|
||||
for i, v := range a[l*lda : l*lda+m] {
|
||||
tmp := alpha * v
|
||||
if tmp != 0 {
|
||||
ctmp := c[i*ldc : i*ldc+n]
|
||||
f32.AxpyUnitary(tmp, btmp, ctmp)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// sgemmSerial where neither a is not transposed and b is
|
||||
func sgemmSerialNotTrans(m, n, k int, a []float32, lda int, b []float32, ldb int, c []float32, ldc int, alpha float32) {
|
||||
// This style is used instead of the literal [i*stride +j]) is used because
|
||||
// approximately 5 times faster as of go 1.3.
|
||||
for i := 0; i < m; i++ {
|
||||
atmp := a[i*lda : i*lda+k]
|
||||
ctmp := c[i*ldc : i*ldc+n]
|
||||
for j := 0; j < n; j++ {
|
||||
ctmp[j] += alpha * f32.DotUnitary(atmp, b[j*ldb:j*ldb+k])
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// sgemmSerial where both are transposed
|
||||
func sgemmSerialTransTrans(m, n, k int, a []float32, lda int, b []float32, ldb int, c []float32, ldc int, alpha float32) {
|
||||
// This style is used instead of the literal [i*stride +j]) is used because
|
||||
// approximately 5 times faster as of go 1.3.
|
||||
for l := 0; l < k; l++ {
|
||||
for i, v := range a[l*lda : l*lda+m] {
|
||||
tmp := alpha * v
|
||||
if tmp != 0 {
|
||||
ctmp := c[i*ldc : i*ldc+n]
|
||||
f32.AxpyInc(tmp, b[l:], ctmp, uintptr(n), uintptr(ldb), 1, 0, 0)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func sliceView32(a []float32, lda, i, j, r, c int) []float32 {
|
||||
return a[i*lda+j : (i+r-1)*lda+j+c]
|
||||
}
|
||||
218
vendor/gonum.org/v1/gonum/blas/gonum/single_precision.bash
generated
vendored
Normal file
218
vendor/gonum.org/v1/gonum/blas/gonum/single_precision.bash
generated
vendored
Normal file
@@ -0,0 +1,218 @@
|
||||
#!/usr/bin/env bash
|
||||
|
||||
# Copyright ©2015 The Gonum Authors. All rights reserved.
|
||||
# Use of this source code is governed by a BSD-style
|
||||
# license that can be found in the LICENSE file.
|
||||
|
||||
WARNINGF32='//\
|
||||
// Float32 implementations are autogenerated and not directly tested.\
|
||||
'
|
||||
WARNINGC64='//\
|
||||
// Complex64 implementations are autogenerated and not directly tested.\
|
||||
'
|
||||
|
||||
# Level1 routines.
|
||||
|
||||
echo Generating level1float32.go
|
||||
echo -e '// Code generated by "go generate gonum.org/v1/gonum/blas/gonum”; DO NOT EDIT.\n' > level1float32.go
|
||||
cat level1float64.go \
|
||||
| gofmt -r 'blas.Float64Level1 -> blas.Float32Level1' \
|
||||
\
|
||||
| gofmt -r 'float64 -> float32' \
|
||||
| gofmt -r 'blas.DrotmParams -> blas.SrotmParams' \
|
||||
\
|
||||
| gofmt -r 'f64.AxpyInc -> f32.AxpyInc' \
|
||||
| gofmt -r 'f64.AxpyUnitary -> f32.AxpyUnitary' \
|
||||
| gofmt -r 'f64.DotUnitary -> f32.DotUnitary' \
|
||||
| gofmt -r 'f64.ScalInc -> f32.ScalInc' \
|
||||
| gofmt -r 'f64.ScalUnitary -> f32.ScalUnitary' \
|
||||
\
|
||||
| sed -e "s_^\(func (Implementation) \)D\(.*\)\$_$WARNINGF32\1S\2_" \
|
||||
-e 's_^// D_// S_' \
|
||||
-e "s_^\(func (Implementation) \)Id\(.*\)\$_$WARNINGF32\1Is\2_" \
|
||||
-e 's_^// Id_// Is_' \
|
||||
-e 's_"gonum.org/v1/gonum/internal/asm/f64"_"gonum.org/v1/gonum/internal/asm/f32"_' \
|
||||
-e 's_"math"_math "gonum.org/v1/gonum/internal/math32"_' \
|
||||
>> level1float32.go
|
||||
|
||||
echo Generating level1cmplx64.go
|
||||
echo -e '// Code generated by "go generate gonum.org/v1/gonum/blas/gonum”; DO NOT EDIT.\n' > level1cmplx64.go
|
||||
cat level1cmplx128.go \
|
||||
| gofmt -r 'blas.Complex128Level1 -> blas.Complex64Level1' \
|
||||
\
|
||||
| gofmt -r 'float64 -> float32' \
|
||||
| gofmt -r 'complex128 -> complex64' \
|
||||
\
|
||||
| gofmt -r 'c128.AxpyInc -> c64.AxpyInc' \
|
||||
| gofmt -r 'c128.AxpyUnitary -> c64.AxpyUnitary' \
|
||||
| gofmt -r 'c128.DotcInc -> c64.DotcInc' \
|
||||
| gofmt -r 'c128.DotcUnitary -> c64.DotcUnitary' \
|
||||
| gofmt -r 'c128.DotuInc -> c64.DotuInc' \
|
||||
| gofmt -r 'c128.DotuUnitary -> c64.DotuUnitary' \
|
||||
| gofmt -r 'c128.ScalInc -> c64.ScalInc' \
|
||||
| gofmt -r 'c128.ScalUnitary -> c64.ScalUnitary' \
|
||||
| gofmt -r 'dcabs1 -> scabs1' \
|
||||
\
|
||||
| sed -e "s_^\(func (Implementation) \)Zdot\(.*\)\$_$WARNINGC64\1Cdot\2_" \
|
||||
-e 's_^// Zdot_// Cdot_' \
|
||||
-e "s_^\(func (Implementation) \)Zdscal\(.*\)\$_$WARNINGC64\1Csscal\2_" \
|
||||
-e 's_^// Zdscal_// Csscal_' \
|
||||
-e "s_^\(func (Implementation) \)Z\(.*\)\$_$WARNINGC64\1C\2_" \
|
||||
-e 's_^// Z_// C_' \
|
||||
-e "s_^\(func (Implementation) \)Iz\(.*\)\$_$WARNINGC64\1Ic\2_" \
|
||||
-e 's_^// Iz_// Ic_' \
|
||||
-e "s_^\(func (Implementation) \)Dz\(.*\)\$_$WARNINGC64\1Sc\2_" \
|
||||
-e 's_^// Dz_// Sc_' \
|
||||
-e 's_"gonum.org/v1/gonum/internal/asm/c128"_"gonum.org/v1/gonum/internal/asm/c64"_' \
|
||||
-e 's_"math"_math "gonum.org/v1/gonum/internal/math32"_' \
|
||||
>> level1cmplx64.go
|
||||
|
||||
echo Generating level1float32_sdot.go
|
||||
echo -e '// Code generated by "go generate gonum.org/v1/gonum/blas/gonum”; DO NOT EDIT.\n' > level1float32_sdot.go
|
||||
cat level1float64_ddot.go \
|
||||
| gofmt -r 'float64 -> float32' \
|
||||
\
|
||||
| gofmt -r 'f64.DotInc -> f32.DotInc' \
|
||||
| gofmt -r 'f64.DotUnitary -> f32.DotUnitary' \
|
||||
\
|
||||
| sed -e "s_^\(func (Implementation) \)D\(.*\)\$_$WARNINGF32\1S\2_" \
|
||||
-e 's_^// D_// S_' \
|
||||
-e 's_"gonum.org/v1/gonum/internal/asm/f64"_"gonum.org/v1/gonum/internal/asm/f32"_' \
|
||||
>> level1float32_sdot.go
|
||||
|
||||
echo Generating level1float32_dsdot.go
|
||||
echo -e '// Code generated by "go generate gonum.org/v1/gonum/blas/gonum”; DO NOT EDIT.\n' > level1float32_dsdot.go
|
||||
cat level1float64_ddot.go \
|
||||
| gofmt -r '[]float64 -> []float32' \
|
||||
\
|
||||
| gofmt -r 'f64.DotInc -> f32.DdotInc' \
|
||||
| gofmt -r 'f64.DotUnitary -> f32.DdotUnitary' \
|
||||
\
|
||||
| sed -e "s_^\(func (Implementation) \)D\(.*\)\$_$WARNINGF32\1Ds\2_" \
|
||||
-e 's_^// D_// Ds_' \
|
||||
-e 's_"gonum.org/v1/gonum/internal/asm/f64"_"gonum.org/v1/gonum/internal/asm/f32"_' \
|
||||
>> level1float32_dsdot.go
|
||||
|
||||
echo Generating level1float32_sdsdot.go
|
||||
echo -e '// Code generated by "go generate gonum.org/v1/gonum/blas/gonum”; DO NOT EDIT.\n' > level1float32_sdsdot.go
|
||||
cat level1float64_ddot.go \
|
||||
| gofmt -r 'float64 -> float32' \
|
||||
\
|
||||
| gofmt -r 'f64.DotInc(x, y, f(n), f(incX), f(incY), f(ix), f(iy)) -> alpha + float32(f32.DdotInc(x, y, f(n), f(incX), f(incY), f(ix), f(iy)))' \
|
||||
| gofmt -r 'f64.DotUnitary(a, b) -> alpha + float32(f32.DdotUnitary(a, b))' \
|
||||
\
|
||||
| sed -e "s_^\(func (Implementation) \)D\(.*\)\$_$WARNINGF32\1Sds\2_" \
|
||||
-e 's_^// D\(.*\)$_// Sds\1 plus a constant_' \
|
||||
-e 's_\\sum_alpha + \\sum_' \
|
||||
-e 's/n int/n int, alpha float32/' \
|
||||
-e 's_"gonum.org/v1/gonum/internal/asm/f64"_"gonum.org/v1/gonum/internal/asm/f32"_' \
|
||||
>> level1float32_sdsdot.go
|
||||
|
||||
|
||||
# Level2 routines.
|
||||
|
||||
echo Generating level2float32.go
|
||||
echo -e '// Code generated by "go generate gonum.org/v1/gonum/blas/gonum”; DO NOT EDIT.\n' > level2float32.go
|
||||
cat level2float64.go \
|
||||
| gofmt -r 'blas.Float64Level2 -> blas.Float32Level2' \
|
||||
\
|
||||
| gofmt -r 'float64 -> float32' \
|
||||
\
|
||||
| gofmt -r 'f64.AxpyInc -> f32.AxpyInc' \
|
||||
| gofmt -r 'f64.AxpyIncTo -> f32.AxpyIncTo' \
|
||||
| gofmt -r 'f64.AxpyUnitary -> f32.AxpyUnitary' \
|
||||
| gofmt -r 'f64.AxpyUnitaryTo -> f32.AxpyUnitaryTo' \
|
||||
| gofmt -r 'f64.DotInc -> f32.DotInc' \
|
||||
| gofmt -r 'f64.DotUnitary -> f32.DotUnitary' \
|
||||
| gofmt -r 'f64.ScalInc -> f32.ScalInc' \
|
||||
| gofmt -r 'f64.ScalUnitary -> f32.ScalUnitary' \
|
||||
| gofmt -r 'f64.Ger -> f32.Ger' \
|
||||
\
|
||||
| sed -e "s_^\(func (Implementation) \)D\(.*\)\$_$WARNINGF32\1S\2_" \
|
||||
-e 's_^// D_// S_' \
|
||||
-e 's_"gonum.org/v1/gonum/internal/asm/f64"_"gonum.org/v1/gonum/internal/asm/f32"_' \
|
||||
>> level2float32.go
|
||||
|
||||
echo Generating level2cmplx64.go
|
||||
echo -e '// Code generated by "go generate gonum.org/v1/gonum/blas/gonum”; DO NOT EDIT.\n' > level2cmplx64.go
|
||||
cat level2cmplx128.go \
|
||||
| gofmt -r 'blas.Complex128Level2 -> blas.Complex64Level2' \
|
||||
\
|
||||
| gofmt -r 'complex128 -> complex64' \
|
||||
| gofmt -r 'float64 -> float32' \
|
||||
\
|
||||
| gofmt -r 'c128.AxpyInc -> c64.AxpyInc' \
|
||||
| gofmt -r 'c128.AxpyUnitary -> c64.AxpyUnitary' \
|
||||
| gofmt -r 'c128.DotuInc -> c64.DotuInc' \
|
||||
| gofmt -r 'c128.DotuUnitary -> c64.DotuUnitary' \
|
||||
| gofmt -r 'c128.ScalInc -> c64.ScalInc' \
|
||||
| gofmt -r 'c128.ScalUnitary -> c64.ScalUnitary' \
|
||||
\
|
||||
| sed -e "s_^\(func (Implementation) \)Z\(.*\)\$_$WARNINGC64\1C\2_" \
|
||||
-e 's_^// Z_// C_' \
|
||||
-e 's_"gonum.org/v1/gonum/internal/asm/c128"_"gonum.org/v1/gonum/internal/asm/c64"_' \
|
||||
-e 's_"math/cmplx"_cmplx "gonum.org/v1/gonum/internal/cmplx64"_' \
|
||||
>> level2cmplx64.go
|
||||
|
||||
# Level3 routines.
|
||||
|
||||
echo Generating level3float32.go
|
||||
echo -e '// Code generated by "go generate gonum.org/v1/gonum/blas/gonum”; DO NOT EDIT.\n' > level3float32.go
|
||||
cat level3float64.go \
|
||||
| gofmt -r 'blas.Float64Level3 -> blas.Float32Level3' \
|
||||
\
|
||||
| gofmt -r 'float64 -> float32' \
|
||||
\
|
||||
| gofmt -r 'f64.AxpyUnitaryTo -> f32.AxpyUnitaryTo' \
|
||||
| gofmt -r 'f64.AxpyUnitary -> f32.AxpyUnitary' \
|
||||
| gofmt -r 'f64.DotUnitary -> f32.DotUnitary' \
|
||||
| gofmt -r 'f64.ScalUnitary -> f32.ScalUnitary' \
|
||||
\
|
||||
| sed -e "s_^\(func (Implementation) \)D\(.*\)\$_$WARNINGF32\1S\2_" \
|
||||
-e 's_^// D_// S_' \
|
||||
-e 's_"gonum.org/v1/gonum/internal/asm/f64"_"gonum.org/v1/gonum/internal/asm/f32"_' \
|
||||
>> level3float32.go
|
||||
|
||||
echo Generating sgemm.go
|
||||
echo -e '// Code generated by "go generate gonum.org/v1/gonum/blas/gonum”; DO NOT EDIT.\n' > sgemm.go
|
||||
cat dgemm.go \
|
||||
| gofmt -r 'float64 -> float32' \
|
||||
| gofmt -r 'sliceView64 -> sliceView32' \
|
||||
\
|
||||
| gofmt -r 'dgemmParallel -> sgemmParallel' \
|
||||
| gofmt -r 'computeNumBlocks64 -> computeNumBlocks32' \
|
||||
| gofmt -r 'dgemmSerial -> sgemmSerial' \
|
||||
| gofmt -r 'dgemmSerialNotNot -> sgemmSerialNotNot' \
|
||||
| gofmt -r 'dgemmSerialTransNot -> sgemmSerialTransNot' \
|
||||
| gofmt -r 'dgemmSerialNotTrans -> sgemmSerialNotTrans' \
|
||||
| gofmt -r 'dgemmSerialTransTrans -> sgemmSerialTransTrans' \
|
||||
\
|
||||
| gofmt -r 'f64.AxpyInc -> f32.AxpyInc' \
|
||||
| gofmt -r 'f64.AxpyUnitary -> f32.AxpyUnitary' \
|
||||
| gofmt -r 'f64.DotUnitary -> f32.DotUnitary' \
|
||||
\
|
||||
| sed -e "s_^\(func (Implementation) \)D\(.*\)\$_$WARNINGF32\1S\2_" \
|
||||
-e 's_^// D_// S_' \
|
||||
-e 's_^// d_// s_' \
|
||||
-e 's_"gonum.org/v1/gonum/internal/asm/f64"_"gonum.org/v1/gonum/internal/asm/f32"_' \
|
||||
>> sgemm.go
|
||||
|
||||
echo Generating level3cmplx64.go
|
||||
echo -e '// Code generated by "go generate gonum.org/v1/gonum/blas/gonum”; DO NOT EDIT.\n' > level3cmplx64.go
|
||||
cat level3cmplx128.go \
|
||||
| gofmt -r 'blas.Complex128Level3 -> blas.Complex64Level3' \
|
||||
\
|
||||
| gofmt -r 'float64 -> float32' \
|
||||
| gofmt -r 'complex128 -> complex64' \
|
||||
\
|
||||
| gofmt -r 'c128.ScalUnitary -> c64.ScalUnitary' \
|
||||
| gofmt -r 'c128.DscalUnitary -> c64.SscalUnitary' \
|
||||
| gofmt -r 'c128.DotcUnitary -> c64.DotcUnitary' \
|
||||
| gofmt -r 'c128.AxpyUnitary -> c64.AxpyUnitary' \
|
||||
| gofmt -r 'c128.DotuUnitary -> c64.DotuUnitary' \
|
||||
\
|
||||
| sed -e "s_^\(func (Implementation) \)Z\(.*\)\$_$WARNINGC64\1C\2_" \
|
||||
-e 's_^// Z_// C_' \
|
||||
-e 's_"gonum.org/v1/gonum/internal/asm/c128"_"gonum.org/v1/gonum/internal/asm/c64"_' \
|
||||
-e 's_"math/cmplx"_cmplx "gonum.org/v1/gonum/internal/cmplx64"_' \
|
||||
>> level3cmplx64.go
|
||||
4
vendor/gonum.org/v1/gonum/floats/README.md
generated
vendored
Normal file
4
vendor/gonum.org/v1/gonum/floats/README.md
generated
vendored
Normal file
@@ -0,0 +1,4 @@
|
||||
# Gonum floats [](https://godoc.org/gonum.org/v1/gonum/floats)
|
||||
|
||||
Package floats provides a set of helper routines for dealing with slices of float64.
|
||||
The functions avoid allocations to allow for use within tight loops without garbage collection overhead.
|
||||
11
vendor/gonum.org/v1/gonum/floats/doc.go
generated
vendored
Normal file
11
vendor/gonum.org/v1/gonum/floats/doc.go
generated
vendored
Normal file
@@ -0,0 +1,11 @@
|
||||
// Copyright ©2017 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
// Package floats provides a set of helper routines for dealing with slices
|
||||
// of float64. The functions avoid allocations to allow for use within tight
|
||||
// loops without garbage collection overhead.
|
||||
//
|
||||
// The convention used is that when a slice is being modified in place, it has
|
||||
// the name dst.
|
||||
package floats // import "gonum.org/v1/gonum/floats"
|
||||
933
vendor/gonum.org/v1/gonum/floats/floats.go
generated
vendored
Normal file
933
vendor/gonum.org/v1/gonum/floats/floats.go
generated
vendored
Normal file
@@ -0,0 +1,933 @@
|
||||
// Copyright ©2013 The Gonum Authors. All rights reserved.
|
||||
// Use of this code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file
|
||||
|
||||
package floats
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"math"
|
||||
"sort"
|
||||
"strconv"
|
||||
|
||||
"gonum.org/v1/gonum/internal/asm/f64"
|
||||
)
|
||||
|
||||
// Add adds, element-wise, the elements of s and dst, and stores in dst.
|
||||
// Panics if the lengths of dst and s do not match.
|
||||
func Add(dst, s []float64) {
|
||||
if len(dst) != len(s) {
|
||||
panic("floats: length of the slices do not match")
|
||||
}
|
||||
f64.AxpyUnitaryTo(dst, 1, s, dst)
|
||||
}
|
||||
|
||||
// AddTo adds, element-wise, the elements of s and t and
|
||||
// stores the result in dst. Panics if the lengths of s, t and dst do not match.
|
||||
func AddTo(dst, s, t []float64) []float64 {
|
||||
if len(s) != len(t) {
|
||||
panic("floats: length of adders do not match")
|
||||
}
|
||||
if len(dst) != len(s) {
|
||||
panic("floats: length of destination does not match length of adder")
|
||||
}
|
||||
f64.AxpyUnitaryTo(dst, 1, s, t)
|
||||
return dst
|
||||
}
|
||||
|
||||
// AddConst adds the scalar c to all of the values in dst.
|
||||
func AddConst(c float64, dst []float64) {
|
||||
f64.AddConst(c, dst)
|
||||
}
|
||||
|
||||
// AddScaled performs dst = dst + alpha * s.
|
||||
// It panics if the lengths of dst and s are not equal.
|
||||
func AddScaled(dst []float64, alpha float64, s []float64) {
|
||||
if len(dst) != len(s) {
|
||||
panic("floats: length of destination and source to not match")
|
||||
}
|
||||
f64.AxpyUnitaryTo(dst, alpha, s, dst)
|
||||
}
|
||||
|
||||
// AddScaledTo performs dst = y + alpha * s, where alpha is a scalar,
|
||||
// and dst, y and s are all slices.
|
||||
// It panics if the lengths of dst, y, and s are not equal.
|
||||
//
|
||||
// At the return of the function, dst[i] = y[i] + alpha * s[i]
|
||||
func AddScaledTo(dst, y []float64, alpha float64, s []float64) []float64 {
|
||||
if len(dst) != len(s) || len(dst) != len(y) {
|
||||
panic("floats: lengths of slices do not match")
|
||||
}
|
||||
f64.AxpyUnitaryTo(dst, alpha, s, y)
|
||||
return dst
|
||||
}
|
||||
|
||||
// argsort is a helper that implements sort.Interface, as used by
|
||||
// Argsort.
|
||||
type argsort struct {
|
||||
s []float64
|
||||
inds []int
|
||||
}
|
||||
|
||||
func (a argsort) Len() int {
|
||||
return len(a.s)
|
||||
}
|
||||
|
||||
func (a argsort) Less(i, j int) bool {
|
||||
return a.s[i] < a.s[j]
|
||||
}
|
||||
|
||||
func (a argsort) Swap(i, j int) {
|
||||
a.s[i], a.s[j] = a.s[j], a.s[i]
|
||||
a.inds[i], a.inds[j] = a.inds[j], a.inds[i]
|
||||
}
|
||||
|
||||
// Argsort sorts the elements of dst while tracking their original order.
|
||||
// At the conclusion of Argsort, dst will contain the original elements of dst
|
||||
// but sorted in increasing order, and inds will contain the original position
|
||||
// of the elements in the slice such that dst[i] = origDst[inds[i]].
|
||||
// It panics if the lengths of dst and inds do not match.
|
||||
func Argsort(dst []float64, inds []int) {
|
||||
if len(dst) != len(inds) {
|
||||
panic("floats: length of inds does not match length of slice")
|
||||
}
|
||||
for i := range dst {
|
||||
inds[i] = i
|
||||
}
|
||||
|
||||
a := argsort{s: dst, inds: inds}
|
||||
sort.Sort(a)
|
||||
}
|
||||
|
||||
// Count applies the function f to every element of s and returns the number
|
||||
// of times the function returned true.
|
||||
func Count(f func(float64) bool, s []float64) int {
|
||||
var n int
|
||||
for _, val := range s {
|
||||
if f(val) {
|
||||
n++
|
||||
}
|
||||
}
|
||||
return n
|
||||
}
|
||||
|
||||
// CumProd finds the cumulative product of the first i elements in
|
||||
// s and puts them in place into the ith element of the
|
||||
// destination dst. A panic will occur if the lengths of arguments
|
||||
// do not match.
|
||||
//
|
||||
// At the return of the function, dst[i] = s[i] * s[i-1] * s[i-2] * ...
|
||||
func CumProd(dst, s []float64) []float64 {
|
||||
if len(dst) != len(s) {
|
||||
panic("floats: length of destination does not match length of the source")
|
||||
}
|
||||
if len(dst) == 0 {
|
||||
return dst
|
||||
}
|
||||
return f64.CumProd(dst, s)
|
||||
}
|
||||
|
||||
// CumSum finds the cumulative sum of the first i elements in
|
||||
// s and puts them in place into the ith element of the
|
||||
// destination dst. A panic will occur if the lengths of arguments
|
||||
// do not match.
|
||||
//
|
||||
// At the return of the function, dst[i] = s[i] + s[i-1] + s[i-2] + ...
|
||||
func CumSum(dst, s []float64) []float64 {
|
||||
if len(dst) != len(s) {
|
||||
panic("floats: length of destination does not match length of the source")
|
||||
}
|
||||
if len(dst) == 0 {
|
||||
return dst
|
||||
}
|
||||
return f64.CumSum(dst, s)
|
||||
}
|
||||
|
||||
// Distance computes the L-norm of s - t. See Norm for special cases.
|
||||
// A panic will occur if the lengths of s and t do not match.
|
||||
func Distance(s, t []float64, L float64) float64 {
|
||||
if len(s) != len(t) {
|
||||
panic("floats: slice lengths do not match")
|
||||
}
|
||||
if len(s) == 0 {
|
||||
return 0
|
||||
}
|
||||
var norm float64
|
||||
if L == 2 {
|
||||
for i, v := range s {
|
||||
diff := t[i] - v
|
||||
norm = math.Hypot(norm, diff)
|
||||
}
|
||||
return norm
|
||||
}
|
||||
if L == 1 {
|
||||
for i, v := range s {
|
||||
norm += math.Abs(t[i] - v)
|
||||
}
|
||||
return norm
|
||||
}
|
||||
if math.IsInf(L, 1) {
|
||||
for i, v := range s {
|
||||
absDiff := math.Abs(t[i] - v)
|
||||
if absDiff > norm {
|
||||
norm = absDiff
|
||||
}
|
||||
}
|
||||
return norm
|
||||
}
|
||||
for i, v := range s {
|
||||
norm += math.Pow(math.Abs(t[i]-v), L)
|
||||
}
|
||||
return math.Pow(norm, 1/L)
|
||||
}
|
||||
|
||||
// Div performs element-wise division dst / s
|
||||
// and stores the value in dst. It panics if the
|
||||
// lengths of s and t are not equal.
|
||||
func Div(dst, s []float64) {
|
||||
if len(dst) != len(s) {
|
||||
panic("floats: slice lengths do not match")
|
||||
}
|
||||
f64.Div(dst, s)
|
||||
}
|
||||
|
||||
// DivTo performs element-wise division s / t
|
||||
// and stores the value in dst. It panics if the
|
||||
// lengths of s, t, and dst are not equal.
|
||||
func DivTo(dst, s, t []float64) []float64 {
|
||||
if len(s) != len(t) || len(dst) != len(t) {
|
||||
panic("floats: slice lengths do not match")
|
||||
}
|
||||
return f64.DivTo(dst, s, t)
|
||||
}
|
||||
|
||||
// Dot computes the dot product of s1 and s2, i.e.
|
||||
// sum_{i = 1}^N s1[i]*s2[i].
|
||||
// A panic will occur if lengths of arguments do not match.
|
||||
func Dot(s1, s2 []float64) float64 {
|
||||
if len(s1) != len(s2) {
|
||||
panic("floats: lengths of the slices do not match")
|
||||
}
|
||||
return f64.DotUnitary(s1, s2)
|
||||
}
|
||||
|
||||
// Equal returns true if the slices have equal lengths and
|
||||
// all elements are numerically identical.
|
||||
func Equal(s1, s2 []float64) bool {
|
||||
if len(s1) != len(s2) {
|
||||
return false
|
||||
}
|
||||
for i, val := range s1 {
|
||||
if s2[i] != val {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// EqualApprox returns true if the slices have equal lengths and
|
||||
// all element pairs have an absolute tolerance less than tol or a
|
||||
// relative tolerance less than tol.
|
||||
func EqualApprox(s1, s2 []float64, tol float64) bool {
|
||||
if len(s1) != len(s2) {
|
||||
return false
|
||||
}
|
||||
for i, a := range s1 {
|
||||
if !EqualWithinAbsOrRel(a, s2[i], tol, tol) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// EqualFunc returns true if the slices have the same lengths
|
||||
// and the function returns true for all element pairs.
|
||||
func EqualFunc(s1, s2 []float64, f func(float64, float64) bool) bool {
|
||||
if len(s1) != len(s2) {
|
||||
return false
|
||||
}
|
||||
for i, val := range s1 {
|
||||
if !f(val, s2[i]) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// EqualWithinAbs returns true if a and b have an absolute
|
||||
// difference of less than tol.
|
||||
func EqualWithinAbs(a, b, tol float64) bool {
|
||||
return a == b || math.Abs(a-b) <= tol
|
||||
}
|
||||
|
||||
const minNormalFloat64 = 2.2250738585072014e-308
|
||||
|
||||
// EqualWithinRel returns true if the difference between a and b
|
||||
// is not greater than tol times the greater value.
|
||||
func EqualWithinRel(a, b, tol float64) bool {
|
||||
if a == b {
|
||||
return true
|
||||
}
|
||||
delta := math.Abs(a - b)
|
||||
if delta <= minNormalFloat64 {
|
||||
return delta <= tol*minNormalFloat64
|
||||
}
|
||||
// We depend on the division in this relationship to identify
|
||||
// infinities (we rely on the NaN to fail the test) otherwise
|
||||
// we compare Infs of the same sign and evaluate Infs as equal
|
||||
// independent of sign.
|
||||
return delta/math.Max(math.Abs(a), math.Abs(b)) <= tol
|
||||
}
|
||||
|
||||
// EqualWithinAbsOrRel returns true if a and b are equal to within
|
||||
// the absolute tolerance.
|
||||
func EqualWithinAbsOrRel(a, b, absTol, relTol float64) bool {
|
||||
if EqualWithinAbs(a, b, absTol) {
|
||||
return true
|
||||
}
|
||||
return EqualWithinRel(a, b, relTol)
|
||||
}
|
||||
|
||||
// EqualWithinULP returns true if a and b are equal to within
|
||||
// the specified number of floating point units in the last place.
|
||||
func EqualWithinULP(a, b float64, ulp uint) bool {
|
||||
if a == b {
|
||||
return true
|
||||
}
|
||||
if math.IsNaN(a) || math.IsNaN(b) {
|
||||
return false
|
||||
}
|
||||
if math.Signbit(a) != math.Signbit(b) {
|
||||
return math.Float64bits(math.Abs(a))+math.Float64bits(math.Abs(b)) <= uint64(ulp)
|
||||
}
|
||||
return ulpDiff(math.Float64bits(a), math.Float64bits(b)) <= uint64(ulp)
|
||||
}
|
||||
|
||||
func ulpDiff(a, b uint64) uint64 {
|
||||
if a > b {
|
||||
return a - b
|
||||
}
|
||||
return b - a
|
||||
}
|
||||
|
||||
// EqualLengths returns true if all of the slices have equal length,
|
||||
// and false otherwise. Returns true if there are no input slices.
|
||||
func EqualLengths(slices ...[]float64) bool {
|
||||
// This length check is needed: http://play.golang.org/p/sdty6YiLhM
|
||||
if len(slices) == 0 {
|
||||
return true
|
||||
}
|
||||
l := len(slices[0])
|
||||
for i := 1; i < len(slices); i++ {
|
||||
if len(slices[i]) != l {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// Find applies f to every element of s and returns the indices of the first
|
||||
// k elements for which the f returns true, or all such elements
|
||||
// if k < 0.
|
||||
// Find will reslice inds to have 0 length, and will append
|
||||
// found indices to inds.
|
||||
// If k > 0 and there are fewer than k elements in s satisfying f,
|
||||
// all of the found elements will be returned along with an error.
|
||||
// At the return of the function, the input inds will be in an undetermined state.
|
||||
func Find(inds []int, f func(float64) bool, s []float64, k int) ([]int, error) {
|
||||
// inds is also returned to allow for calling with nil
|
||||
|
||||
// Reslice inds to have zero length
|
||||
inds = inds[:0]
|
||||
|
||||
// If zero elements requested, can just return
|
||||
if k == 0 {
|
||||
return inds, nil
|
||||
}
|
||||
|
||||
// If k < 0, return all of the found indices
|
||||
if k < 0 {
|
||||
for i, val := range s {
|
||||
if f(val) {
|
||||
inds = append(inds, i)
|
||||
}
|
||||
}
|
||||
return inds, nil
|
||||
}
|
||||
|
||||
// Otherwise, find the first k elements
|
||||
nFound := 0
|
||||
for i, val := range s {
|
||||
if f(val) {
|
||||
inds = append(inds, i)
|
||||
nFound++
|
||||
if nFound == k {
|
||||
return inds, nil
|
||||
}
|
||||
}
|
||||
}
|
||||
// Finished iterating over the loop, which means k elements were not found
|
||||
return inds, errors.New("floats: insufficient elements found")
|
||||
}
|
||||
|
||||
// HasNaN returns true if the slice s has any values that are NaN and false
|
||||
// otherwise.
|
||||
func HasNaN(s []float64) bool {
|
||||
for _, v := range s {
|
||||
if math.IsNaN(v) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// LogSpan returns a set of n equally spaced points in log space between,
|
||||
// l and u where N is equal to len(dst). The first element of the
|
||||
// resulting dst will be l and the final element of dst will be u.
|
||||
// Panics if len(dst) < 2
|
||||
// Note that this call will return NaNs if either l or u are negative, and
|
||||
// will return all zeros if l or u is zero.
|
||||
// Also returns the mutated slice dst, so that it can be used in range, like:
|
||||
//
|
||||
// for i, x := range LogSpan(dst, l, u) { ... }
|
||||
func LogSpan(dst []float64, l, u float64) []float64 {
|
||||
Span(dst, math.Log(l), math.Log(u))
|
||||
for i := range dst {
|
||||
dst[i] = math.Exp(dst[i])
|
||||
}
|
||||
return dst
|
||||
}
|
||||
|
||||
// LogSumExp returns the log of the sum of the exponentials of the values in s.
|
||||
// Panics if s is an empty slice.
|
||||
func LogSumExp(s []float64) float64 {
|
||||
// Want to do this in a numerically stable way which avoids
|
||||
// overflow and underflow
|
||||
// First, find the maximum value in the slice.
|
||||
maxval := Max(s)
|
||||
if math.IsInf(maxval, 0) {
|
||||
// If it's infinity either way, the logsumexp will be infinity as well
|
||||
// returning now avoids NaNs
|
||||
return maxval
|
||||
}
|
||||
var lse float64
|
||||
// Compute the sumexp part
|
||||
for _, val := range s {
|
||||
lse += math.Exp(val - maxval)
|
||||
}
|
||||
// Take the log and add back on the constant taken out
|
||||
return math.Log(lse) + maxval
|
||||
}
|
||||
|
||||
// Max returns the maximum value in the input slice. If the slice is empty, Max will panic.
|
||||
func Max(s []float64) float64 {
|
||||
return s[MaxIdx(s)]
|
||||
}
|
||||
|
||||
// MaxIdx returns the index of the maximum value in the input slice. If several
|
||||
// entries have the maximum value, the first such index is returned. If the slice
|
||||
// is empty, MaxIdx will panic.
|
||||
func MaxIdx(s []float64) int {
|
||||
if len(s) == 0 {
|
||||
panic("floats: zero slice length")
|
||||
}
|
||||
max := math.NaN()
|
||||
var ind int
|
||||
for i, v := range s {
|
||||
if math.IsNaN(v) {
|
||||
continue
|
||||
}
|
||||
if v > max || math.IsNaN(max) {
|
||||
max = v
|
||||
ind = i
|
||||
}
|
||||
}
|
||||
return ind
|
||||
}
|
||||
|
||||
// Min returns the maximum value in the input slice. If the slice is empty, Min will panic.
|
||||
func Min(s []float64) float64 {
|
||||
return s[MinIdx(s)]
|
||||
}
|
||||
|
||||
// MinIdx returns the index of the minimum value in the input slice. If several
|
||||
// entries have the maximum value, the first such index is returned. If the slice
|
||||
// is empty, MinIdx will panic.
|
||||
func MinIdx(s []float64) int {
|
||||
if len(s) == 0 {
|
||||
panic("floats: zero slice length")
|
||||
}
|
||||
min := math.NaN()
|
||||
var ind int
|
||||
for i, v := range s {
|
||||
if math.IsNaN(v) {
|
||||
continue
|
||||
}
|
||||
if v < min || math.IsNaN(min) {
|
||||
min = v
|
||||
ind = i
|
||||
}
|
||||
}
|
||||
return ind
|
||||
}
|
||||
|
||||
// Mul performs element-wise multiplication between dst
|
||||
// and s and stores the value in dst. Panics if the
|
||||
// lengths of s and t are not equal.
|
||||
func Mul(dst, s []float64) {
|
||||
if len(dst) != len(s) {
|
||||
panic("floats: slice lengths do not match")
|
||||
}
|
||||
for i, val := range s {
|
||||
dst[i] *= val
|
||||
}
|
||||
}
|
||||
|
||||
// MulTo performs element-wise multiplication between s
|
||||
// and t and stores the value in dst. Panics if the
|
||||
// lengths of s, t, and dst are not equal.
|
||||
func MulTo(dst, s, t []float64) []float64 {
|
||||
if len(s) != len(t) || len(dst) != len(t) {
|
||||
panic("floats: slice lengths do not match")
|
||||
}
|
||||
for i, val := range t {
|
||||
dst[i] = val * s[i]
|
||||
}
|
||||
return dst
|
||||
}
|
||||
|
||||
const (
|
||||
nanBits = 0x7ff8000000000000
|
||||
nanMask = 0xfff8000000000000
|
||||
)
|
||||
|
||||
// NaNWith returns an IEEE 754 "quiet not-a-number" value with the
|
||||
// payload specified in the low 51 bits of payload.
|
||||
// The NaN returned by math.NaN has a bit pattern equal to NaNWith(1).
|
||||
func NaNWith(payload uint64) float64 {
|
||||
return math.Float64frombits(nanBits | (payload &^ nanMask))
|
||||
}
|
||||
|
||||
// NaNPayload returns the lowest 51 bits payload of an IEEE 754 "quiet
|
||||
// not-a-number". For values of f other than quiet-NaN, NaNPayload
|
||||
// returns zero and false.
|
||||
func NaNPayload(f float64) (payload uint64, ok bool) {
|
||||
b := math.Float64bits(f)
|
||||
if b&nanBits != nanBits {
|
||||
return 0, false
|
||||
}
|
||||
return b &^ nanMask, true
|
||||
}
|
||||
|
||||
// NearestIdx returns the index of the element in s
|
||||
// whose value is nearest to v. If several such
|
||||
// elements exist, the lowest index is returned.
|
||||
// NearestIdx panics if len(s) == 0.
|
||||
func NearestIdx(s []float64, v float64) int {
|
||||
if len(s) == 0 {
|
||||
panic("floats: zero length slice")
|
||||
}
|
||||
switch {
|
||||
case math.IsNaN(v):
|
||||
return 0
|
||||
case math.IsInf(v, 1):
|
||||
return MaxIdx(s)
|
||||
case math.IsInf(v, -1):
|
||||
return MinIdx(s)
|
||||
}
|
||||
var ind int
|
||||
dist := math.NaN()
|
||||
for i, val := range s {
|
||||
newDist := math.Abs(v - val)
|
||||
// A NaN distance will not be closer.
|
||||
if math.IsNaN(newDist) {
|
||||
continue
|
||||
}
|
||||
if newDist < dist || math.IsNaN(dist) {
|
||||
dist = newDist
|
||||
ind = i
|
||||
}
|
||||
}
|
||||
return ind
|
||||
}
|
||||
|
||||
// NearestIdxForSpan return the index of a hypothetical vector created
|
||||
// by Span with length n and bounds l and u whose value is closest
|
||||
// to v. That is, NearestIdxForSpan(n, l, u, v) is equivalent to
|
||||
// Nearest(Span(make([]float64, n),l,u),v) without an allocation.
|
||||
// NearestIdxForSpan panics if n is less than two.
|
||||
func NearestIdxForSpan(n int, l, u float64, v float64) int {
|
||||
if n <= 1 {
|
||||
panic("floats: span must have length >1")
|
||||
}
|
||||
if math.IsNaN(v) {
|
||||
return 0
|
||||
}
|
||||
|
||||
// Special cases for Inf and NaN.
|
||||
switch {
|
||||
case math.IsNaN(l) && !math.IsNaN(u):
|
||||
return n - 1
|
||||
case math.IsNaN(u):
|
||||
return 0
|
||||
case math.IsInf(l, 0) && math.IsInf(u, 0):
|
||||
if l == u {
|
||||
return 0
|
||||
}
|
||||
if n%2 == 1 {
|
||||
if !math.IsInf(v, 0) {
|
||||
return n / 2
|
||||
}
|
||||
if math.Copysign(1, v) == math.Copysign(1, l) {
|
||||
return 0
|
||||
}
|
||||
return n/2 + 1
|
||||
}
|
||||
if math.Copysign(1, v) == math.Copysign(1, l) {
|
||||
return 0
|
||||
}
|
||||
return n / 2
|
||||
case math.IsInf(l, 0):
|
||||
if v == l {
|
||||
return 0
|
||||
}
|
||||
return n - 1
|
||||
case math.IsInf(u, 0):
|
||||
if v == u {
|
||||
return n - 1
|
||||
}
|
||||
return 0
|
||||
case math.IsInf(v, -1):
|
||||
if l <= u {
|
||||
return 0
|
||||
}
|
||||
return n - 1
|
||||
case math.IsInf(v, 1):
|
||||
if u <= l {
|
||||
return 0
|
||||
}
|
||||
return n - 1
|
||||
}
|
||||
|
||||
// Special cases for v outside (l, u) and (u, l).
|
||||
switch {
|
||||
case l < u:
|
||||
if v <= l {
|
||||
return 0
|
||||
}
|
||||
if v >= u {
|
||||
return n - 1
|
||||
}
|
||||
case l > u:
|
||||
if v >= l {
|
||||
return 0
|
||||
}
|
||||
if v <= u {
|
||||
return n - 1
|
||||
}
|
||||
default:
|
||||
return 0
|
||||
}
|
||||
|
||||
// Can't guarantee anything about exactly halfway between
|
||||
// because of floating point weirdness.
|
||||
return int((float64(n)-1)/(u-l)*(v-l) + 0.5)
|
||||
}
|
||||
|
||||
// Norm returns the L norm of the slice S, defined as
|
||||
// (sum_{i=1}^N s[i]^L)^{1/L}
|
||||
// Special cases:
|
||||
// L = math.Inf(1) gives the maximum absolute value.
|
||||
// Does not correctly compute the zero norm (use Count).
|
||||
func Norm(s []float64, L float64) float64 {
|
||||
// Should this complain if L is not positive?
|
||||
// Should this be done in log space for better numerical stability?
|
||||
// would be more cost
|
||||
// maybe only if L is high?
|
||||
if len(s) == 0 {
|
||||
return 0
|
||||
}
|
||||
if L == 2 {
|
||||
twoNorm := math.Abs(s[0])
|
||||
for i := 1; i < len(s); i++ {
|
||||
twoNorm = math.Hypot(twoNorm, s[i])
|
||||
}
|
||||
return twoNorm
|
||||
}
|
||||
var norm float64
|
||||
if L == 1 {
|
||||
for _, val := range s {
|
||||
norm += math.Abs(val)
|
||||
}
|
||||
return norm
|
||||
}
|
||||
if math.IsInf(L, 1) {
|
||||
for _, val := range s {
|
||||
norm = math.Max(norm, math.Abs(val))
|
||||
}
|
||||
return norm
|
||||
}
|
||||
for _, val := range s {
|
||||
norm += math.Pow(math.Abs(val), L)
|
||||
}
|
||||
return math.Pow(norm, 1/L)
|
||||
}
|
||||
|
||||
// ParseWithNA converts the string s to a float64 in v.
|
||||
// If s equals missing, w is returned as 0, otherwise 1.
|
||||
func ParseWithNA(s, missing string) (v, w float64, err error) {
|
||||
if s == missing {
|
||||
return 0, 0, nil
|
||||
}
|
||||
v, err = strconv.ParseFloat(s, 64)
|
||||
if err == nil {
|
||||
w = 1
|
||||
}
|
||||
return v, w, err
|
||||
}
|
||||
|
||||
// Prod returns the product of the elements of the slice.
|
||||
// Returns 1 if len(s) = 0.
|
||||
func Prod(s []float64) float64 {
|
||||
prod := 1.0
|
||||
for _, val := range s {
|
||||
prod *= val
|
||||
}
|
||||
return prod
|
||||
}
|
||||
|
||||
// Reverse reverses the order of elements in the slice.
|
||||
func Reverse(s []float64) {
|
||||
for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {
|
||||
s[i], s[j] = s[j], s[i]
|
||||
}
|
||||
}
|
||||
|
||||
// Round returns the half away from zero rounded value of x with prec precision.
|
||||
//
|
||||
// Special cases are:
|
||||
// Round(±0) = +0
|
||||
// Round(±Inf) = ±Inf
|
||||
// Round(NaN) = NaN
|
||||
func Round(x float64, prec int) float64 {
|
||||
if x == 0 {
|
||||
// Make sure zero is returned
|
||||
// without the negative bit set.
|
||||
return 0
|
||||
}
|
||||
// Fast path for positive precision on integers.
|
||||
if prec >= 0 && x == math.Trunc(x) {
|
||||
return x
|
||||
}
|
||||
pow := math.Pow10(prec)
|
||||
intermed := x * pow
|
||||
if math.IsInf(intermed, 0) {
|
||||
return x
|
||||
}
|
||||
if x < 0 {
|
||||
x = math.Ceil(intermed - 0.5)
|
||||
} else {
|
||||
x = math.Floor(intermed + 0.5)
|
||||
}
|
||||
|
||||
if x == 0 {
|
||||
return 0
|
||||
}
|
||||
|
||||
return x / pow
|
||||
}
|
||||
|
||||
// RoundEven returns the half even rounded value of x with prec precision.
|
||||
//
|
||||
// Special cases are:
|
||||
// RoundEven(±0) = +0
|
||||
// RoundEven(±Inf) = ±Inf
|
||||
// RoundEven(NaN) = NaN
|
||||
func RoundEven(x float64, prec int) float64 {
|
||||
if x == 0 {
|
||||
// Make sure zero is returned
|
||||
// without the negative bit set.
|
||||
return 0
|
||||
}
|
||||
// Fast path for positive precision on integers.
|
||||
if prec >= 0 && x == math.Trunc(x) {
|
||||
return x
|
||||
}
|
||||
pow := math.Pow10(prec)
|
||||
intermed := x * pow
|
||||
if math.IsInf(intermed, 0) {
|
||||
return x
|
||||
}
|
||||
if isHalfway(intermed) {
|
||||
correction, _ := math.Modf(math.Mod(intermed, 2))
|
||||
intermed += correction
|
||||
if intermed > 0 {
|
||||
x = math.Floor(intermed)
|
||||
} else {
|
||||
x = math.Ceil(intermed)
|
||||
}
|
||||
} else {
|
||||
if x < 0 {
|
||||
x = math.Ceil(intermed - 0.5)
|
||||
} else {
|
||||
x = math.Floor(intermed + 0.5)
|
||||
}
|
||||
}
|
||||
|
||||
if x == 0 {
|
||||
return 0
|
||||
}
|
||||
|
||||
return x / pow
|
||||
}
|
||||
|
||||
func isHalfway(x float64) bool {
|
||||
_, frac := math.Modf(x)
|
||||
frac = math.Abs(frac)
|
||||
return frac == 0.5 || (math.Nextafter(frac, math.Inf(-1)) < 0.5 && math.Nextafter(frac, math.Inf(1)) > 0.5)
|
||||
}
|
||||
|
||||
// Same returns true if the input slices have the same length and the all elements
|
||||
// have the same value with NaN treated as the same.
|
||||
func Same(s, t []float64) bool {
|
||||
if len(s) != len(t) {
|
||||
return false
|
||||
}
|
||||
for i, v := range s {
|
||||
w := t[i]
|
||||
if v != w && !(math.IsNaN(v) && math.IsNaN(w)) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// Scale multiplies every element in dst by the scalar c.
|
||||
func Scale(c float64, dst []float64) {
|
||||
if len(dst) > 0 {
|
||||
f64.ScalUnitary(c, dst)
|
||||
}
|
||||
}
|
||||
|
||||
// ScaleTo multiplies the elements in s by c and stores the result in dst.
|
||||
func ScaleTo(dst []float64, c float64, s []float64) []float64 {
|
||||
if len(dst) != len(s) {
|
||||
panic("floats: lengths of slices do not match")
|
||||
}
|
||||
if len(dst) > 0 {
|
||||
f64.ScalUnitaryTo(dst, c, s)
|
||||
}
|
||||
return dst
|
||||
}
|
||||
|
||||
// Span returns a set of N equally spaced points between l and u, where N
|
||||
// is equal to the length of the destination. The first element of the destination
|
||||
// is l, the final element of the destination is u.
|
||||
//
|
||||
// Panics if len(dst) < 2.
|
||||
//
|
||||
// Span also returns the mutated slice dst, so that it can be used in range expressions,
|
||||
// like:
|
||||
//
|
||||
// for i, x := range Span(dst, l, u) { ... }
|
||||
func Span(dst []float64, l, u float64) []float64 {
|
||||
n := len(dst)
|
||||
if n < 2 {
|
||||
panic("floats: destination must have length >1")
|
||||
}
|
||||
|
||||
// Special cases for Inf and NaN.
|
||||
switch {
|
||||
case math.IsNaN(l):
|
||||
for i := range dst[:len(dst)-1] {
|
||||
dst[i] = math.NaN()
|
||||
}
|
||||
dst[len(dst)-1] = u
|
||||
return dst
|
||||
case math.IsNaN(u):
|
||||
for i := range dst[1:] {
|
||||
dst[i+1] = math.NaN()
|
||||
}
|
||||
dst[0] = l
|
||||
return dst
|
||||
case math.IsInf(l, 0) && math.IsInf(u, 0):
|
||||
for i := range dst[:len(dst)/2] {
|
||||
dst[i] = l
|
||||
dst[len(dst)-i-1] = u
|
||||
}
|
||||
if len(dst)%2 == 1 {
|
||||
if l != u {
|
||||
dst[len(dst)/2] = 0
|
||||
} else {
|
||||
dst[len(dst)/2] = l
|
||||
}
|
||||
}
|
||||
return dst
|
||||
case math.IsInf(l, 0):
|
||||
for i := range dst[:len(dst)-1] {
|
||||
dst[i] = l
|
||||
}
|
||||
dst[len(dst)-1] = u
|
||||
return dst
|
||||
case math.IsInf(u, 0):
|
||||
for i := range dst[1:] {
|
||||
dst[i+1] = u
|
||||
}
|
||||
dst[0] = l
|
||||
return dst
|
||||
}
|
||||
|
||||
step := (u - l) / float64(n-1)
|
||||
for i := range dst {
|
||||
dst[i] = l + step*float64(i)
|
||||
}
|
||||
return dst
|
||||
}
|
||||
|
||||
// Sub subtracts, element-wise, the elements of s from dst. Panics if
|
||||
// the lengths of dst and s do not match.
|
||||
func Sub(dst, s []float64) {
|
||||
if len(dst) != len(s) {
|
||||
panic("floats: length of the slices do not match")
|
||||
}
|
||||
f64.AxpyUnitaryTo(dst, -1, s, dst)
|
||||
}
|
||||
|
||||
// SubTo subtracts, element-wise, the elements of t from s and
|
||||
// stores the result in dst. Panics if the lengths of s, t and dst do not match.
|
||||
func SubTo(dst, s, t []float64) []float64 {
|
||||
if len(s) != len(t) {
|
||||
panic("floats: length of subtractor and subtractee do not match")
|
||||
}
|
||||
if len(dst) != len(s) {
|
||||
panic("floats: length of destination does not match length of subtractor")
|
||||
}
|
||||
f64.AxpyUnitaryTo(dst, -1, t, s)
|
||||
return dst
|
||||
}
|
||||
|
||||
// Sum returns the sum of the elements of the slice.
|
||||
func Sum(s []float64) float64 {
|
||||
return f64.Sum(s)
|
||||
}
|
||||
|
||||
// Within returns the first index i where s[i] <= v < s[i+1]. Within panics if:
|
||||
// - len(s) < 2
|
||||
// - s is not sorted
|
||||
func Within(s []float64, v float64) int {
|
||||
if len(s) < 2 {
|
||||
panic("floats: slice length less than 2")
|
||||
}
|
||||
if !sort.Float64sAreSorted(s) {
|
||||
panic("floats: input slice not sorted")
|
||||
}
|
||||
if v < s[0] || v >= s[len(s)-1] || math.IsNaN(v) {
|
||||
return -1
|
||||
}
|
||||
for i, f := range s[1:] {
|
||||
if v < f {
|
||||
return i
|
||||
}
|
||||
}
|
||||
return -1
|
||||
}
|
||||
1
vendor/gonum.org/v1/gonum/graph/.gitignore
generated
vendored
Normal file
1
vendor/gonum.org/v1/gonum/graph/.gitignore
generated
vendored
Normal file
@@ -0,0 +1 @@
|
||||
test.out
|
||||
3
vendor/gonum.org/v1/gonum/graph/README.md
generated
vendored
Normal file
3
vendor/gonum.org/v1/gonum/graph/README.md
generated
vendored
Normal file
@@ -0,0 +1,3 @@
|
||||
# Gonum graph [](https://godoc.org/gonum.org/v1/gonum/graph)
|
||||
|
||||
This is a generalized graph package for the Go language.
|
||||
9
vendor/gonum.org/v1/gonum/graph/doc.go
generated
vendored
Normal file
9
vendor/gonum.org/v1/gonum/graph/doc.go
generated
vendored
Normal file
@@ -0,0 +1,9 @@
|
||||
// Copyright ©2014 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
// Package graph defines graph interfaces.
|
||||
//
|
||||
// Routines to test contract compliance by user implemented graph types
|
||||
// are available in gonum.org/v1/gonum/graph/testgraph.
|
||||
package graph // import "gonum.org/v1/gonum/graph"
|
||||
282
vendor/gonum.org/v1/gonum/graph/graph.go
generated
vendored
Normal file
282
vendor/gonum.org/v1/gonum/graph/graph.go
generated
vendored
Normal file
@@ -0,0 +1,282 @@
|
||||
// Copyright ©2014 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package graph
|
||||
|
||||
// Node is a graph node. It returns a graph-unique integer ID.
|
||||
type Node interface {
|
||||
ID() int64
|
||||
}
|
||||
|
||||
// Edge is a graph edge. In directed graphs, the direction of the
|
||||
// edge is given from -> to, otherwise the edge is semantically
|
||||
// unordered.
|
||||
type Edge interface {
|
||||
// From returns the from node of the edge.
|
||||
From() Node
|
||||
|
||||
// To returns the to node of the edge.
|
||||
To() Node
|
||||
|
||||
// ReversedEdge returns an edge that has
|
||||
// the end points of the receiver swapped.
|
||||
ReversedEdge() Edge
|
||||
}
|
||||
|
||||
// WeightedEdge is a weighted graph edge. In directed graphs, the direction
|
||||
// of the edge is given from -> to, otherwise the edge is semantically
|
||||
// unordered.
|
||||
type WeightedEdge interface {
|
||||
Edge
|
||||
Weight() float64
|
||||
}
|
||||
|
||||
// Graph is a generalized graph.
|
||||
type Graph interface {
|
||||
// Node returns the node with the given ID if it exists
|
||||
// in the graph, and nil otherwise.
|
||||
Node(id int64) Node
|
||||
|
||||
// Nodes returns all the nodes in the graph.
|
||||
//
|
||||
// Nodes must not return nil.
|
||||
Nodes() Nodes
|
||||
|
||||
// From returns all nodes that can be reached directly
|
||||
// from the node with the given ID.
|
||||
//
|
||||
// From must not return nil.
|
||||
From(id int64) Nodes
|
||||
|
||||
// HasEdgeBetween returns whether an edge exists between
|
||||
// nodes with IDs xid and yid without considering direction.
|
||||
HasEdgeBetween(xid, yid int64) bool
|
||||
|
||||
// Edge returns the edge from u to v, with IDs uid and vid,
|
||||
// if such an edge exists and nil otherwise. The node v
|
||||
// must be directly reachable from u as defined by the
|
||||
// From method.
|
||||
Edge(uid, vid int64) Edge
|
||||
}
|
||||
|
||||
// Weighted is a weighted graph.
|
||||
type Weighted interface {
|
||||
Graph
|
||||
|
||||
// WeightedEdge returns the weighted edge from u to v
|
||||
// with IDs uid and vid if such an edge exists and
|
||||
// nil otherwise. The node v must be directly
|
||||
// reachable from u as defined by the From method.
|
||||
WeightedEdge(uid, vid int64) WeightedEdge
|
||||
|
||||
// Weight returns the weight for the edge between
|
||||
// x and y with IDs xid and yid if Edge(xid, yid)
|
||||
// returns a non-nil Edge.
|
||||
// If x and y are the same node or there is no
|
||||
// joining edge between the two nodes the weight
|
||||
// value returned is implementation dependent.
|
||||
// Weight returns true if an edge exists between
|
||||
// x and y or if x and y have the same ID, false
|
||||
// otherwise.
|
||||
Weight(xid, yid int64) (w float64, ok bool)
|
||||
}
|
||||
|
||||
// Undirected is an undirected graph.
|
||||
type Undirected interface {
|
||||
Graph
|
||||
|
||||
// EdgeBetween returns the edge between nodes x and y
|
||||
// with IDs xid and yid.
|
||||
EdgeBetween(xid, yid int64) Edge
|
||||
}
|
||||
|
||||
// WeightedUndirected is a weighted undirected graph.
|
||||
type WeightedUndirected interface {
|
||||
Weighted
|
||||
|
||||
// WeightedEdgeBetween returns the edge between nodes
|
||||
// x and y with IDs xid and yid.
|
||||
WeightedEdgeBetween(xid, yid int64) WeightedEdge
|
||||
}
|
||||
|
||||
// Directed is a directed graph.
|
||||
type Directed interface {
|
||||
Graph
|
||||
|
||||
// HasEdgeFromTo returns whether an edge exists
|
||||
// in the graph from u to v with IDs uid and vid.
|
||||
HasEdgeFromTo(uid, vid int64) bool
|
||||
|
||||
// To returns all nodes that can reach directly
|
||||
// to the node with the given ID.
|
||||
//
|
||||
// To must not return nil.
|
||||
To(id int64) Nodes
|
||||
}
|
||||
|
||||
// WeightedDirected is a weighted directed graph.
|
||||
type WeightedDirected interface {
|
||||
Weighted
|
||||
|
||||
// HasEdgeFromTo returns whether an edge exists
|
||||
// in the graph from u to v with the IDs uid and
|
||||
// vid.
|
||||
HasEdgeFromTo(uid, vid int64) bool
|
||||
|
||||
// To returns all nodes that can reach directly
|
||||
// to the node with the given ID.
|
||||
//
|
||||
// To must not return nil.
|
||||
To(id int64) Nodes
|
||||
}
|
||||
|
||||
// NodeAdder is an interface for adding arbitrary nodes to a graph.
|
||||
type NodeAdder interface {
|
||||
// NewNode returns a new Node with a unique
|
||||
// arbitrary ID.
|
||||
NewNode() Node
|
||||
|
||||
// AddNode adds a node to the graph. AddNode panics if
|
||||
// the added node ID matches an existing node ID.
|
||||
AddNode(Node)
|
||||
}
|
||||
|
||||
// NodeRemover is an interface for removing nodes from a graph.
|
||||
type NodeRemover interface {
|
||||
// RemoveNode removes the node with the given ID
|
||||
// from the graph, as well as any edges attached
|
||||
// to it. If the node is not in the graph it is
|
||||
// a no-op.
|
||||
RemoveNode(id int64)
|
||||
}
|
||||
|
||||
// EdgeAdder is an interface for adding edges to a graph.
|
||||
type EdgeAdder interface {
|
||||
// NewEdge returns a new Edge from the source to the destination node.
|
||||
NewEdge(from, to Node) Edge
|
||||
|
||||
// SetEdge adds an edge from one node to another.
|
||||
// If the graph supports node addition the nodes
|
||||
// will be added if they do not exist, otherwise
|
||||
// SetEdge will panic.
|
||||
// The behavior of an EdgeAdder when the IDs
|
||||
// returned by e.From() and e.To() are equal is
|
||||
// implementation-dependent.
|
||||
// Whether e, e.From() and e.To() are stored
|
||||
// within the graph is implementation dependent.
|
||||
SetEdge(e Edge)
|
||||
}
|
||||
|
||||
// WeightedEdgeAdder is an interface for adding edges to a graph.
|
||||
type WeightedEdgeAdder interface {
|
||||
// NewWeightedEdge returns a new WeightedEdge from
|
||||
// the source to the destination node.
|
||||
NewWeightedEdge(from, to Node, weight float64) WeightedEdge
|
||||
|
||||
// SetWeightedEdge adds an edge from one node to
|
||||
// another. If the graph supports node addition
|
||||
// the nodes will be added if they do not exist,
|
||||
// otherwise SetWeightedEdge will panic.
|
||||
// The behavior of a WeightedEdgeAdder when the IDs
|
||||
// returned by e.From() and e.To() are equal is
|
||||
// implementation-dependent.
|
||||
// Whether e, e.From() and e.To() are stored
|
||||
// within the graph is implementation dependent.
|
||||
SetWeightedEdge(e WeightedEdge)
|
||||
}
|
||||
|
||||
// EdgeRemover is an interface for removing nodes from a graph.
|
||||
type EdgeRemover interface {
|
||||
// RemoveEdge removes the edge with the given end
|
||||
// IDs, leaving the terminal nodes. If the edge
|
||||
// does not exist it is a no-op.
|
||||
RemoveEdge(fid, tid int64)
|
||||
}
|
||||
|
||||
// Builder is a graph that can have nodes and edges added.
|
||||
type Builder interface {
|
||||
NodeAdder
|
||||
EdgeAdder
|
||||
}
|
||||
|
||||
// WeightedBuilder is a graph that can have nodes and weighted edges added.
|
||||
type WeightedBuilder interface {
|
||||
NodeAdder
|
||||
WeightedEdgeAdder
|
||||
}
|
||||
|
||||
// UndirectedBuilder is an undirected graph builder.
|
||||
type UndirectedBuilder interface {
|
||||
Undirected
|
||||
Builder
|
||||
}
|
||||
|
||||
// UndirectedWeightedBuilder is an undirected weighted graph builder.
|
||||
type UndirectedWeightedBuilder interface {
|
||||
Undirected
|
||||
WeightedBuilder
|
||||
}
|
||||
|
||||
// DirectedBuilder is a directed graph builder.
|
||||
type DirectedBuilder interface {
|
||||
Directed
|
||||
Builder
|
||||
}
|
||||
|
||||
// DirectedWeightedBuilder is a directed weighted graph builder.
|
||||
type DirectedWeightedBuilder interface {
|
||||
Directed
|
||||
WeightedBuilder
|
||||
}
|
||||
|
||||
// Copy copies nodes and edges as undirected edges from the source to the destination
|
||||
// without first clearing the destination. Copy will panic if a node ID in the source
|
||||
// graph matches a node ID in the destination.
|
||||
//
|
||||
// If the source is undirected and the destination is directed both directions will
|
||||
// be present in the destination after the copy is complete.
|
||||
func Copy(dst Builder, src Graph) {
|
||||
nodes := src.Nodes()
|
||||
for nodes.Next() {
|
||||
dst.AddNode(nodes.Node())
|
||||
}
|
||||
nodes.Reset()
|
||||
for nodes.Next() {
|
||||
u := nodes.Node()
|
||||
uid := u.ID()
|
||||
to := src.From(uid)
|
||||
for to.Next() {
|
||||
v := to.Node()
|
||||
dst.SetEdge(src.Edge(uid, v.ID()))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// CopyWeighted copies nodes and edges as undirected edges from the source to the destination
|
||||
// without first clearing the destination. Copy will panic if a node ID in the source
|
||||
// graph matches a node ID in the destination.
|
||||
//
|
||||
// If the source is undirected and the destination is directed both directions will
|
||||
// be present in the destination after the copy is complete.
|
||||
//
|
||||
// If the source is a directed graph, the destination is undirected, and a fundamental
|
||||
// cycle exists with two nodes where the edge weights differ, the resulting destination
|
||||
// graph's edge weight between those nodes is undefined. If there is a defined function
|
||||
// to resolve such conflicts, an UndirectWeighted may be used to do this.
|
||||
func CopyWeighted(dst WeightedBuilder, src Weighted) {
|
||||
nodes := src.Nodes()
|
||||
for nodes.Next() {
|
||||
dst.AddNode(nodes.Node())
|
||||
}
|
||||
nodes.Reset()
|
||||
for nodes.Next() {
|
||||
u := nodes.Node()
|
||||
uid := u.ID()
|
||||
to := src.From(uid)
|
||||
for to.Next() {
|
||||
v := to.Node()
|
||||
dst.SetWeightedEdge(src.WeightedEdge(uid, v.ID()))
|
||||
}
|
||||
}
|
||||
}
|
||||
6
vendor/gonum.org/v1/gonum/graph/internal/linear/doc.go
generated
vendored
Normal file
6
vendor/gonum.org/v1/gonum/graph/internal/linear/doc.go
generated
vendored
Normal file
@@ -0,0 +1,6 @@
|
||||
// Copyright ©2017 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
// Package linear provides common linear data structures.
|
||||
package linear // import "gonum.org/v1/gonum/graph/internal/linear"
|
||||
73
vendor/gonum.org/v1/gonum/graph/internal/linear/linear.go
generated
vendored
Normal file
73
vendor/gonum.org/v1/gonum/graph/internal/linear/linear.go
generated
vendored
Normal file
@@ -0,0 +1,73 @@
|
||||
// Copyright ©2015 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package linear
|
||||
|
||||
import (
|
||||
"gonum.org/v1/gonum/graph"
|
||||
)
|
||||
|
||||
// NodeStack implements a LIFO stack of graph.Node.
|
||||
type NodeStack []graph.Node
|
||||
|
||||
// Len returns the number of graph.Nodes on the stack.
|
||||
func (s *NodeStack) Len() int { return len(*s) }
|
||||
|
||||
// Pop returns the last graph.Node on the stack and removes it
|
||||
// from the stack.
|
||||
func (s *NodeStack) Pop() graph.Node {
|
||||
v := *s
|
||||
v, n := v[:len(v)-1], v[len(v)-1]
|
||||
*s = v
|
||||
return n
|
||||
}
|
||||
|
||||
// Push adds the node n to the stack at the last position.
|
||||
func (s *NodeStack) Push(n graph.Node) { *s = append(*s, n) }
|
||||
|
||||
// NodeQueue implements a FIFO queue.
|
||||
type NodeQueue struct {
|
||||
head int
|
||||
data []graph.Node
|
||||
}
|
||||
|
||||
// Len returns the number of graph.Nodes in the queue.
|
||||
func (q *NodeQueue) Len() int { return len(q.data) - q.head }
|
||||
|
||||
// Enqueue adds the node n to the back of the queue.
|
||||
func (q *NodeQueue) Enqueue(n graph.Node) {
|
||||
if len(q.data) == cap(q.data) && q.head > 0 {
|
||||
l := q.Len()
|
||||
copy(q.data, q.data[q.head:])
|
||||
q.head = 0
|
||||
q.data = append(q.data[:l], n)
|
||||
} else {
|
||||
q.data = append(q.data, n)
|
||||
}
|
||||
}
|
||||
|
||||
// Dequeue returns the graph.Node at the front of the queue and
|
||||
// removes it from the queue.
|
||||
func (q *NodeQueue) Dequeue() graph.Node {
|
||||
if q.Len() == 0 {
|
||||
panic("queue: empty queue")
|
||||
}
|
||||
|
||||
var n graph.Node
|
||||
n, q.data[q.head] = q.data[q.head], nil
|
||||
q.head++
|
||||
|
||||
if q.Len() == 0 {
|
||||
q.head = 0
|
||||
q.data = q.data[:0]
|
||||
}
|
||||
|
||||
return n
|
||||
}
|
||||
|
||||
// Reset clears the queue for reuse.
|
||||
func (q *NodeQueue) Reset() {
|
||||
q.head = 0
|
||||
q.data = q.data[:0]
|
||||
}
|
||||
6
vendor/gonum.org/v1/gonum/graph/internal/ordered/doc.go
generated
vendored
Normal file
6
vendor/gonum.org/v1/gonum/graph/internal/ordered/doc.go
generated
vendored
Normal file
@@ -0,0 +1,6 @@
|
||||
// Copyright ©2017 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
// Package ordered provides common sort ordering types.
|
||||
package ordered // import "gonum.org/v1/gonum/graph/internal/ordered"
|
||||
93
vendor/gonum.org/v1/gonum/graph/internal/ordered/sort.go
generated
vendored
Normal file
93
vendor/gonum.org/v1/gonum/graph/internal/ordered/sort.go
generated
vendored
Normal file
@@ -0,0 +1,93 @@
|
||||
// Copyright ©2015 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package ordered
|
||||
|
||||
import "gonum.org/v1/gonum/graph"
|
||||
|
||||
// ByID implements the sort.Interface sorting a slice of graph.Node
|
||||
// by ID.
|
||||
type ByID []graph.Node
|
||||
|
||||
func (n ByID) Len() int { return len(n) }
|
||||
func (n ByID) Less(i, j int) bool { return n[i].ID() < n[j].ID() }
|
||||
func (n ByID) Swap(i, j int) { n[i], n[j] = n[j], n[i] }
|
||||
|
||||
// BySliceValues implements the sort.Interface sorting a slice of
|
||||
// []int64 lexically by the values of the []int64.
|
||||
type BySliceValues [][]int64
|
||||
|
||||
func (c BySliceValues) Len() int { return len(c) }
|
||||
func (c BySliceValues) Less(i, j int) bool {
|
||||
a, b := c[i], c[j]
|
||||
l := len(a)
|
||||
if len(b) < l {
|
||||
l = len(b)
|
||||
}
|
||||
for k, v := range a[:l] {
|
||||
if v < b[k] {
|
||||
return true
|
||||
}
|
||||
if v > b[k] {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return len(a) < len(b)
|
||||
}
|
||||
func (c BySliceValues) Swap(i, j int) { c[i], c[j] = c[j], c[i] }
|
||||
|
||||
// BySliceIDs implements the sort.Interface sorting a slice of
|
||||
// []graph.Node lexically by the IDs of the []graph.Node.
|
||||
type BySliceIDs [][]graph.Node
|
||||
|
||||
func (c BySliceIDs) Len() int { return len(c) }
|
||||
func (c BySliceIDs) Less(i, j int) bool {
|
||||
a, b := c[i], c[j]
|
||||
l := len(a)
|
||||
if len(b) < l {
|
||||
l = len(b)
|
||||
}
|
||||
for k, v := range a[:l] {
|
||||
if v.ID() < b[k].ID() {
|
||||
return true
|
||||
}
|
||||
if v.ID() > b[k].ID() {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return len(a) < len(b)
|
||||
}
|
||||
func (c BySliceIDs) Swap(i, j int) { c[i], c[j] = c[j], c[i] }
|
||||
|
||||
// Int64s implements the sort.Interface sorting a slice of
|
||||
// int64.
|
||||
type Int64s []int64
|
||||
|
||||
func (s Int64s) Len() int { return len(s) }
|
||||
func (s Int64s) Less(i, j int) bool { return s[i] < s[j] }
|
||||
func (s Int64s) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
|
||||
|
||||
// Reverse reverses the order of nodes.
|
||||
func Reverse(nodes []graph.Node) {
|
||||
for i, j := 0, len(nodes)-1; i < j; i, j = i+1, j-1 {
|
||||
nodes[i], nodes[j] = nodes[j], nodes[i]
|
||||
}
|
||||
}
|
||||
|
||||
// LinesByIDs implements the sort.Interface sorting a slice of graph.LinesByIDs
|
||||
// lexically by the From IDs, then by the To IDs, finally by the Line IDs.
|
||||
type LinesByIDs []graph.Line
|
||||
|
||||
func (n LinesByIDs) Len() int { return len(n) }
|
||||
func (n LinesByIDs) Less(i, j int) bool {
|
||||
a, b := n[i], n[j]
|
||||
if a.From().ID() != b.From().ID() {
|
||||
return a.From().ID() < b.From().ID()
|
||||
}
|
||||
if a.To().ID() != b.To().ID() {
|
||||
return a.To().ID() < b.To().ID()
|
||||
}
|
||||
return n[i].ID() < n[j].ID()
|
||||
}
|
||||
func (n LinesByIDs) Swap(i, j int) { n[i], n[j] = n[j], n[i] }
|
||||
6
vendor/gonum.org/v1/gonum/graph/internal/set/doc.go
generated
vendored
Normal file
6
vendor/gonum.org/v1/gonum/graph/internal/set/doc.go
generated
vendored
Normal file
@@ -0,0 +1,6 @@
|
||||
// Copyright ©2017 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
// Package set provides integer and graph.Node sets.
|
||||
package set // import "gonum.org/v1/gonum/graph/internal/set"
|
||||
36
vendor/gonum.org/v1/gonum/graph/internal/set/same.go
generated
vendored
Normal file
36
vendor/gonum.org/v1/gonum/graph/internal/set/same.go
generated
vendored
Normal file
@@ -0,0 +1,36 @@
|
||||
// Copyright ©2014 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
// +build !appengine,!safe
|
||||
|
||||
package set
|
||||
|
||||
import "unsafe"
|
||||
|
||||
// same determines whether two sets are backed by the same store. In the
|
||||
// current implementation using hash maps it makes use of the fact that
|
||||
// hash maps are passed as a pointer to a runtime Hmap struct. A map is
|
||||
// not seen by the runtime as a pointer though, so we use unsafe to get
|
||||
// the maps' pointer values to compare.
|
||||
func same(a, b Nodes) bool {
|
||||
return *(*uintptr)(unsafe.Pointer(&a)) == *(*uintptr)(unsafe.Pointer(&b))
|
||||
}
|
||||
|
||||
// intsSame determines whether two sets are backed by the same store. In the
|
||||
// current implementation using hash maps it makes use of the fact that
|
||||
// hash maps are passed as a pointer to a runtime Hmap struct. A map is
|
||||
// not seen by the runtime as a pointer though, so we use unsafe to get
|
||||
// the maps' pointer values to compare.
|
||||
func intsSame(a, b Ints) bool {
|
||||
return *(*uintptr)(unsafe.Pointer(&a)) == *(*uintptr)(unsafe.Pointer(&b))
|
||||
}
|
||||
|
||||
// int64sSame determines whether two sets are backed by the same store. In the
|
||||
// current implementation using hash maps it makes use of the fact that
|
||||
// hash maps are passed as a pointer to a runtime Hmap struct. A map is
|
||||
// not seen by the runtime as a pointer though, so we use unsafe to get
|
||||
// the maps' pointer values to compare.
|
||||
func int64sSame(a, b Int64s) bool {
|
||||
return *(*uintptr)(unsafe.Pointer(&a)) == *(*uintptr)(unsafe.Pointer(&b))
|
||||
}
|
||||
36
vendor/gonum.org/v1/gonum/graph/internal/set/same_appengine.go
generated
vendored
Normal file
36
vendor/gonum.org/v1/gonum/graph/internal/set/same_appengine.go
generated
vendored
Normal file
@@ -0,0 +1,36 @@
|
||||
// Copyright ©2014 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
// +build appengine safe
|
||||
|
||||
package set
|
||||
|
||||
import "reflect"
|
||||
|
||||
// same determines whether two sets are backed by the same store. In the
|
||||
// current implementation using hash maps it makes use of the fact that
|
||||
// hash maps are passed as a pointer to a runtime Hmap struct. A map is
|
||||
// not seen by the runtime as a pointer though, so we use reflect to get
|
||||
// the maps' pointer values to compare.
|
||||
func same(a, b Nodes) bool {
|
||||
return reflect.ValueOf(a).Pointer() == reflect.ValueOf(b).Pointer()
|
||||
}
|
||||
|
||||
// intsSame determines whether two sets are backed by the same store. In the
|
||||
// current implementation using hash maps it makes use of the fact that
|
||||
// hash maps are passed as a pointer to a runtime Hmap struct. A map is
|
||||
// not seen by the runtime as a pointer though, so we use reflect to get
|
||||
// the maps' pointer values to compare.
|
||||
func intsSame(a, b Ints) bool {
|
||||
return reflect.ValueOf(a).Pointer() == reflect.ValueOf(b).Pointer()
|
||||
}
|
||||
|
||||
// int64sSame determines whether two sets are backed by the same store. In the
|
||||
// current implementation using hash maps it makes use of the fact that
|
||||
// hash maps are passed as a pointer to a runtime Hmap struct. A map is
|
||||
// not seen by the runtime as a pointer though, so we use reflect to get
|
||||
// the maps' pointer values to compare.
|
||||
func int64sSame(a, b Int64s) bool {
|
||||
return reflect.ValueOf(a).Pointer() == reflect.ValueOf(b).Pointer()
|
||||
}
|
||||
228
vendor/gonum.org/v1/gonum/graph/internal/set/set.go
generated
vendored
Normal file
228
vendor/gonum.org/v1/gonum/graph/internal/set/set.go
generated
vendored
Normal file
@@ -0,0 +1,228 @@
|
||||
// Copyright ©2014 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package set
|
||||
|
||||
import "gonum.org/v1/gonum/graph"
|
||||
|
||||
// Ints is a set of int identifiers.
|
||||
type Ints map[int]struct{}
|
||||
|
||||
// The simple accessor methods for Ints are provided to allow ease of
|
||||
// implementation change should the need arise.
|
||||
|
||||
// Add inserts an element into the set.
|
||||
func (s Ints) Add(e int) {
|
||||
s[e] = struct{}{}
|
||||
}
|
||||
|
||||
// Has reports the existence of the element in the set.
|
||||
func (s Ints) Has(e int) bool {
|
||||
_, ok := s[e]
|
||||
return ok
|
||||
}
|
||||
|
||||
// Remove deletes the specified element from the set.
|
||||
func (s Ints) Remove(e int) {
|
||||
delete(s, e)
|
||||
}
|
||||
|
||||
// Count reports the number of elements stored in the set.
|
||||
func (s Ints) Count() int {
|
||||
return len(s)
|
||||
}
|
||||
|
||||
// IntsEqual reports set equality between the parameters. Sets are equal if
|
||||
// and only if they have the same elements.
|
||||
func IntsEqual(a, b Ints) bool {
|
||||
if intsSame(a, b) {
|
||||
return true
|
||||
}
|
||||
|
||||
if len(a) != len(b) {
|
||||
return false
|
||||
}
|
||||
|
||||
for e := range a {
|
||||
if _, ok := b[e]; !ok {
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
// Int64s is a set of int64 identifiers.
|
||||
type Int64s map[int64]struct{}
|
||||
|
||||
// The simple accessor methods for Ints are provided to allow ease of
|
||||
// implementation change should the need arise.
|
||||
|
||||
// Add inserts an element into the set.
|
||||
func (s Int64s) Add(e int64) {
|
||||
s[e] = struct{}{}
|
||||
}
|
||||
|
||||
// Has reports the existence of the element in the set.
|
||||
func (s Int64s) Has(e int64) bool {
|
||||
_, ok := s[e]
|
||||
return ok
|
||||
}
|
||||
|
||||
// Remove deletes the specified element from the set.
|
||||
func (s Int64s) Remove(e int64) {
|
||||
delete(s, e)
|
||||
}
|
||||
|
||||
// Count reports the number of elements stored in the set.
|
||||
func (s Int64s) Count() int {
|
||||
return len(s)
|
||||
}
|
||||
|
||||
// Int64sEqual reports set equality between the parameters. Sets are equal if
|
||||
// and only if they have the same elements.
|
||||
func Int64sEqual(a, b Int64s) bool {
|
||||
if int64sSame(a, b) {
|
||||
return true
|
||||
}
|
||||
|
||||
if len(a) != len(b) {
|
||||
return false
|
||||
}
|
||||
|
||||
for e := range a {
|
||||
if _, ok := b[e]; !ok {
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
// Nodes is a set of nodes keyed in their integer identifiers.
|
||||
type Nodes map[int64]graph.Node
|
||||
|
||||
// NewNodes returns a new Nodes.
|
||||
func NewNodes() Nodes {
|
||||
return make(Nodes)
|
||||
}
|
||||
|
||||
// NewNodes returns a new Nodes with the given size hint, n.
|
||||
func NewNodesSize(n int) Nodes {
|
||||
return make(Nodes, n)
|
||||
}
|
||||
|
||||
// The simple accessor methods for Nodes are provided to allow ease of
|
||||
// implementation change should the need arise.
|
||||
|
||||
// Add inserts an element into the set.
|
||||
func (s Nodes) Add(n graph.Node) {
|
||||
s[n.ID()] = n
|
||||
}
|
||||
|
||||
// Remove deletes the specified element from the set.
|
||||
func (s Nodes) Remove(e graph.Node) {
|
||||
delete(s, e.ID())
|
||||
}
|
||||
|
||||
// Count returns the number of element in the set.
|
||||
func (s Nodes) Count() int {
|
||||
return len(s)
|
||||
}
|
||||
|
||||
// Has reports the existence of the elements in the set.
|
||||
func (s Nodes) Has(n graph.Node) bool {
|
||||
_, ok := s[n.ID()]
|
||||
return ok
|
||||
}
|
||||
|
||||
// CloneNodes returns a clone of src.
|
||||
func CloneNodes(src Nodes) Nodes {
|
||||
dst := make(Nodes, len(src))
|
||||
for e, n := range src {
|
||||
dst[e] = n
|
||||
}
|
||||
return dst
|
||||
}
|
||||
|
||||
// Equal reports set equality between the parameters. Sets are equal if
|
||||
// and only if they have the same elements.
|
||||
func Equal(a, b Nodes) bool {
|
||||
if same(a, b) {
|
||||
return true
|
||||
}
|
||||
|
||||
if len(a) != len(b) {
|
||||
return false
|
||||
}
|
||||
|
||||
for e := range a {
|
||||
if _, ok := b[e]; !ok {
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
// UnionOfNodes returns the union of a and b.
|
||||
//
|
||||
// The union of two sets, a and b, is the set containing all the
|
||||
// elements of each, for instance:
|
||||
//
|
||||
// {a,b,c} UNION {d,e,f} = {a,b,c,d,e,f}
|
||||
//
|
||||
// Since sets may not have repetition, unions of two sets that overlap
|
||||
// do not contain repeat elements, that is:
|
||||
//
|
||||
// {a,b,c} UNION {b,c,d} = {a,b,c,d}
|
||||
//
|
||||
func UnionOfNodes(a, b Nodes) Nodes {
|
||||
if same(a, b) {
|
||||
return CloneNodes(a)
|
||||
}
|
||||
|
||||
dst := make(Nodes)
|
||||
for e, n := range a {
|
||||
dst[e] = n
|
||||
}
|
||||
for e, n := range b {
|
||||
dst[e] = n
|
||||
}
|
||||
|
||||
return dst
|
||||
}
|
||||
|
||||
// IntersectionOfNodes returns the intersection of a and b.
|
||||
//
|
||||
// The intersection of two sets, a and b, is the set containing all
|
||||
// the elements shared between the two sets, for instance:
|
||||
//
|
||||
// {a,b,c} INTERSECT {b,c,d} = {b,c}
|
||||
//
|
||||
// The intersection between a set and itself is itself, and thus
|
||||
// effectively a copy operation:
|
||||
//
|
||||
// {a,b,c} INTERSECT {a,b,c} = {a,b,c}
|
||||
//
|
||||
// The intersection between two sets that share no elements is the empty
|
||||
// set:
|
||||
//
|
||||
// {a,b,c} INTERSECT {d,e,f} = {}
|
||||
//
|
||||
func IntersectionOfNodes(a, b Nodes) Nodes {
|
||||
if same(a, b) {
|
||||
return CloneNodes(a)
|
||||
}
|
||||
dst := make(Nodes)
|
||||
if len(a) > len(b) {
|
||||
a, b = b, a
|
||||
}
|
||||
for e, n := range a {
|
||||
if _, ok := b[e]; ok {
|
||||
dst[e] = n
|
||||
}
|
||||
}
|
||||
return dst
|
||||
}
|
||||
54
vendor/gonum.org/v1/gonum/graph/internal/uid/uid.go
generated
vendored
Normal file
54
vendor/gonum.org/v1/gonum/graph/internal/uid/uid.go
generated
vendored
Normal file
@@ -0,0 +1,54 @@
|
||||
// Copyright ©2014 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
// Package uid implements unique ID provision for graphs.
|
||||
package uid
|
||||
|
||||
import "gonum.org/v1/gonum/graph/internal/set"
|
||||
|
||||
// Max is the maximum value of int64.
|
||||
const Max = int64(^uint64(0) >> 1)
|
||||
|
||||
// Set implements available ID storage.
|
||||
type Set struct {
|
||||
maxID int64
|
||||
used, free set.Int64s
|
||||
}
|
||||
|
||||
// NewSet returns a new Set. The returned value should not be passed except by pointer.
|
||||
func NewSet() Set {
|
||||
return Set{maxID: -1, used: make(set.Int64s), free: make(set.Int64s)}
|
||||
}
|
||||
|
||||
// NewID returns a new unique ID. The ID returned is not considered used
|
||||
// until passed in a call to use.
|
||||
func (s *Set) NewID() int64 {
|
||||
for id := range s.free {
|
||||
return id
|
||||
}
|
||||
if s.maxID != Max {
|
||||
return s.maxID + 1
|
||||
}
|
||||
for id := int64(0); id <= s.maxID+1; id++ {
|
||||
if !s.used.Has(id) {
|
||||
return id
|
||||
}
|
||||
}
|
||||
panic("unreachable")
|
||||
}
|
||||
|
||||
// Use adds the id to the used IDs in the Set.
|
||||
func (s *Set) Use(id int64) {
|
||||
s.used.Add(id)
|
||||
s.free.Remove(id)
|
||||
if id > s.maxID {
|
||||
s.maxID = id
|
||||
}
|
||||
}
|
||||
|
||||
// Release frees the id for reuse.
|
||||
func (s *Set) Release(id int64) {
|
||||
s.free.Add(id)
|
||||
s.used.Remove(id)
|
||||
}
|
||||
9
vendor/gonum.org/v1/gonum/graph/iterator/doc.go
generated
vendored
Normal file
9
vendor/gonum.org/v1/gonum/graph/iterator/doc.go
generated
vendored
Normal file
@@ -0,0 +1,9 @@
|
||||
// Copyright ©2018 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
// Package iterator provides node, edge and line iterators.
|
||||
//
|
||||
// The iterators provided satisfy the graph.Nodes, graph.Edges and
|
||||
// graph.Lines interfaces.
|
||||
package iterator
|
||||
131
vendor/gonum.org/v1/gonum/graph/iterator/edges.go
generated
vendored
Normal file
131
vendor/gonum.org/v1/gonum/graph/iterator/edges.go
generated
vendored
Normal file
@@ -0,0 +1,131 @@
|
||||
// Copyright ©2018 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package iterator
|
||||
|
||||
import "gonum.org/v1/gonum/graph"
|
||||
|
||||
// OrderedEdges implements the graph.Edges and graph.EdgeSlicer interfaces.
|
||||
// The iteration order of OrderedEdges is the order of edges passed to
|
||||
// NewEdgeIterator.
|
||||
type OrderedEdges struct {
|
||||
idx int
|
||||
edges []graph.Edge
|
||||
}
|
||||
|
||||
// NewOrderedEdges returns an OrderedEdges initialized with the provided edges.
|
||||
func NewOrderedEdges(edges []graph.Edge) *OrderedEdges {
|
||||
return &OrderedEdges{idx: -1, edges: edges}
|
||||
}
|
||||
|
||||
// Len returns the remaining number of edges to be iterated over.
|
||||
func (e *OrderedEdges) Len() int {
|
||||
if e.idx >= len(e.edges) {
|
||||
return 0
|
||||
}
|
||||
if e.idx <= 0 {
|
||||
return len(e.edges)
|
||||
}
|
||||
return len(e.edges[e.idx:])
|
||||
}
|
||||
|
||||
// Next returns whether the next call of Edge will return a valid edge.
|
||||
func (e *OrderedEdges) Next() bool {
|
||||
if uint(e.idx)+1 < uint(len(e.edges)) {
|
||||
e.idx++
|
||||
return true
|
||||
}
|
||||
e.idx = len(e.edges)
|
||||
return false
|
||||
}
|
||||
|
||||
// Edge returns the current edge of the iterator. Next must have been
|
||||
// called prior to a call to Edge.
|
||||
func (e *OrderedEdges) Edge() graph.Edge {
|
||||
if e.idx >= len(e.edges) || e.idx < 0 {
|
||||
return nil
|
||||
}
|
||||
return e.edges[e.idx]
|
||||
}
|
||||
|
||||
// EdgeSlice returns all the remaining edges in the iterator and advances
|
||||
// the iterator.
|
||||
func (e *OrderedEdges) EdgeSlice() []graph.Edge {
|
||||
if e.idx >= len(e.edges) {
|
||||
return nil
|
||||
}
|
||||
idx := e.idx
|
||||
if idx == -1 {
|
||||
idx = 0
|
||||
}
|
||||
e.idx = len(e.edges)
|
||||
return e.edges[idx:]
|
||||
}
|
||||
|
||||
// Reset returns the iterator to its initial state.
|
||||
func (e *OrderedEdges) Reset() {
|
||||
e.idx = -1
|
||||
}
|
||||
|
||||
// OrderedWeightedEdges implements the graph.Edges and graph.EdgeSlicer interfaces.
|
||||
// The iteration order of OrderedWeightedEdges is the order of edges passed to
|
||||
// NewEdgeIterator.
|
||||
type OrderedWeightedEdges struct {
|
||||
idx int
|
||||
edges []graph.WeightedEdge
|
||||
}
|
||||
|
||||
// NewOrderedWeightedEdges returns an OrderedWeightedEdges initialized with the provided edges.
|
||||
func NewOrderedWeightedEdges(edges []graph.WeightedEdge) *OrderedWeightedEdges {
|
||||
return &OrderedWeightedEdges{idx: -1, edges: edges}
|
||||
}
|
||||
|
||||
// Len returns the remaining number of edges to be iterated over.
|
||||
func (e *OrderedWeightedEdges) Len() int {
|
||||
if e.idx >= len(e.edges) {
|
||||
return 0
|
||||
}
|
||||
if e.idx <= 0 {
|
||||
return len(e.edges)
|
||||
}
|
||||
return len(e.edges[e.idx:])
|
||||
}
|
||||
|
||||
// Next returns whether the next call of WeightedEdge will return a valid edge.
|
||||
func (e *OrderedWeightedEdges) Next() bool {
|
||||
if uint(e.idx)+1 < uint(len(e.edges)) {
|
||||
e.idx++
|
||||
return true
|
||||
}
|
||||
e.idx = len(e.edges)
|
||||
return false
|
||||
}
|
||||
|
||||
// WeightedEdge returns the current edge of the iterator. Next must have been
|
||||
// called prior to a call to WeightedEdge.
|
||||
func (e *OrderedWeightedEdges) WeightedEdge() graph.WeightedEdge {
|
||||
if e.idx >= len(e.edges) || e.idx < 0 {
|
||||
return nil
|
||||
}
|
||||
return e.edges[e.idx]
|
||||
}
|
||||
|
||||
// WeightedEdgeSlice returns all the remaining edges in the iterator and advances
|
||||
// the iterator.
|
||||
func (e *OrderedWeightedEdges) WeightedEdgeSlice() []graph.WeightedEdge {
|
||||
if e.idx >= len(e.edges) {
|
||||
return nil
|
||||
}
|
||||
idx := e.idx
|
||||
if idx == -1 {
|
||||
idx = 0
|
||||
}
|
||||
e.idx = len(e.edges)
|
||||
return e.edges[idx:]
|
||||
}
|
||||
|
||||
// Reset returns the iterator to its initial state.
|
||||
func (e *OrderedWeightedEdges) Reset() {
|
||||
e.idx = -1
|
||||
}
|
||||
131
vendor/gonum.org/v1/gonum/graph/iterator/lines.go
generated
vendored
Normal file
131
vendor/gonum.org/v1/gonum/graph/iterator/lines.go
generated
vendored
Normal file
@@ -0,0 +1,131 @@
|
||||
// Copyright ©2018 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package iterator
|
||||
|
||||
import "gonum.org/v1/gonum/graph"
|
||||
|
||||
// OrderedLines implements the graph.Lines and graph.LineSlicer interfaces.
|
||||
// The iteration order of OrderedLines is the order of lines passed to
|
||||
// NewLineIterator.
|
||||
type OrderedLines struct {
|
||||
idx int
|
||||
lines []graph.Line
|
||||
}
|
||||
|
||||
// NewOrderedLines returns an OrderedLines initialized with the provided lines.
|
||||
func NewOrderedLines(lines []graph.Line) *OrderedLines {
|
||||
return &OrderedLines{idx: -1, lines: lines}
|
||||
}
|
||||
|
||||
// Len returns the remaining number of lines to be iterated over.
|
||||
func (e *OrderedLines) Len() int {
|
||||
if e.idx >= len(e.lines) {
|
||||
return 0
|
||||
}
|
||||
if e.idx <= 0 {
|
||||
return len(e.lines)
|
||||
}
|
||||
return len(e.lines[e.idx:])
|
||||
}
|
||||
|
||||
// Next returns whether the next call of Line will return a valid line.
|
||||
func (e *OrderedLines) Next() bool {
|
||||
if uint(e.idx)+1 < uint(len(e.lines)) {
|
||||
e.idx++
|
||||
return true
|
||||
}
|
||||
e.idx = len(e.lines)
|
||||
return false
|
||||
}
|
||||
|
||||
// Line returns the current line of the iterator. Next must have been
|
||||
// called prior to a call to Line.
|
||||
func (e *OrderedLines) Line() graph.Line {
|
||||
if e.idx >= len(e.lines) || e.idx < 0 {
|
||||
return nil
|
||||
}
|
||||
return e.lines[e.idx]
|
||||
}
|
||||
|
||||
// LineSlice returns all the remaining lines in the iterator and advances
|
||||
// the iterator.
|
||||
func (e *OrderedLines) LineSlice() []graph.Line {
|
||||
if e.idx >= len(e.lines) {
|
||||
return nil
|
||||
}
|
||||
idx := e.idx
|
||||
if idx == -1 {
|
||||
idx = 0
|
||||
}
|
||||
e.idx = len(e.lines)
|
||||
return e.lines[idx:]
|
||||
}
|
||||
|
||||
// Reset returns the iterator to its initial state.
|
||||
func (e *OrderedLines) Reset() {
|
||||
e.idx = -1
|
||||
}
|
||||
|
||||
// OrderedWeightedLines implements the graph.Lines and graph.LineSlicer interfaces.
|
||||
// The iteration order of OrderedWeightedLines is the order of lines passed to
|
||||
// NewLineIterator.
|
||||
type OrderedWeightedLines struct {
|
||||
idx int
|
||||
lines []graph.WeightedLine
|
||||
}
|
||||
|
||||
// NewWeightedLineIterator returns an OrderedWeightedLines initialized with the provided lines.
|
||||
func NewOrderedWeightedLines(lines []graph.WeightedLine) *OrderedWeightedLines {
|
||||
return &OrderedWeightedLines{idx: -1, lines: lines}
|
||||
}
|
||||
|
||||
// Len returns the remaining number of lines to be iterated over.
|
||||
func (e *OrderedWeightedLines) Len() int {
|
||||
if e.idx >= len(e.lines) {
|
||||
return 0
|
||||
}
|
||||
if e.idx <= 0 {
|
||||
return len(e.lines)
|
||||
}
|
||||
return len(e.lines[e.idx:])
|
||||
}
|
||||
|
||||
// Next returns whether the next call of WeightedLine will return a valid line.
|
||||
func (e *OrderedWeightedLines) Next() bool {
|
||||
if uint(e.idx)+1 < uint(len(e.lines)) {
|
||||
e.idx++
|
||||
return true
|
||||
}
|
||||
e.idx = len(e.lines)
|
||||
return false
|
||||
}
|
||||
|
||||
// WeightedLine returns the current line of the iterator. Next must have been
|
||||
// called prior to a call to WeightedLine.
|
||||
func (e *OrderedWeightedLines) WeightedLine() graph.WeightedLine {
|
||||
if e.idx >= len(e.lines) || e.idx < 0 {
|
||||
return nil
|
||||
}
|
||||
return e.lines[e.idx]
|
||||
}
|
||||
|
||||
// WeightedLineSlice returns all the remaining lines in the iterator and advances
|
||||
// the iterator.
|
||||
func (e *OrderedWeightedLines) WeightedLineSlice() []graph.WeightedLine {
|
||||
if e.idx >= len(e.lines) {
|
||||
return nil
|
||||
}
|
||||
idx := e.idx
|
||||
if idx == -1 {
|
||||
idx = 0
|
||||
}
|
||||
e.idx = len(e.lines)
|
||||
return e.lines[idx:]
|
||||
}
|
||||
|
||||
// Reset returns the iterator to its initial state.
|
||||
func (e *OrderedWeightedLines) Reset() {
|
||||
e.idx = -1
|
||||
}
|
||||
125
vendor/gonum.org/v1/gonum/graph/iterator/nodes.go
generated
vendored
Normal file
125
vendor/gonum.org/v1/gonum/graph/iterator/nodes.go
generated
vendored
Normal file
@@ -0,0 +1,125 @@
|
||||
// Copyright ©2018 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package iterator
|
||||
|
||||
import "gonum.org/v1/gonum/graph"
|
||||
|
||||
// OrderedNodes implements the graph.Nodes and graph.NodeSlicer interfaces.
|
||||
// The iteration order of OrderedNodes is the order of nodes passed to
|
||||
// NewNodeIterator.
|
||||
type OrderedNodes struct {
|
||||
idx int
|
||||
nodes []graph.Node
|
||||
}
|
||||
|
||||
// NewOrderedNodes returns a OrderedNodes initialized with the provided nodes.
|
||||
func NewOrderedNodes(nodes []graph.Node) *OrderedNodes {
|
||||
return &OrderedNodes{idx: -1, nodes: nodes}
|
||||
}
|
||||
|
||||
// Len returns the remaining number of nodes to be iterated over.
|
||||
func (n *OrderedNodes) Len() int {
|
||||
if n.idx >= len(n.nodes) {
|
||||
return 0
|
||||
}
|
||||
if n.idx <= 0 {
|
||||
return len(n.nodes)
|
||||
}
|
||||
return len(n.nodes[n.idx:])
|
||||
}
|
||||
|
||||
// Next returns whether the next call of Node will return a valid node.
|
||||
func (n *OrderedNodes) Next() bool {
|
||||
if uint(n.idx)+1 < uint(len(n.nodes)) {
|
||||
n.idx++
|
||||
return true
|
||||
}
|
||||
n.idx = len(n.nodes)
|
||||
return false
|
||||
}
|
||||
|
||||
// Node returns the current node of the iterator. Next must have been
|
||||
// called prior to a call to Node.
|
||||
func (n *OrderedNodes) Node() graph.Node {
|
||||
if n.idx >= len(n.nodes) || n.idx < 0 {
|
||||
return nil
|
||||
}
|
||||
return n.nodes[n.idx]
|
||||
}
|
||||
|
||||
// NodeSlice returns all the remaining nodes in the iterator and advances
|
||||
// the iterator.
|
||||
func (n *OrderedNodes) NodeSlice() []graph.Node {
|
||||
if n.idx >= len(n.nodes) {
|
||||
return nil
|
||||
}
|
||||
idx := n.idx
|
||||
if idx == -1 {
|
||||
idx = 0
|
||||
}
|
||||
n.idx = len(n.nodes)
|
||||
return n.nodes[idx:]
|
||||
}
|
||||
|
||||
// Reset returns the iterator to its initial state.
|
||||
func (n *OrderedNodes) Reset() {
|
||||
n.idx = -1
|
||||
}
|
||||
|
||||
// ImplicitNodes implements the graph.Nodes interface for a set of nodes over
|
||||
// a contiguous ID range.
|
||||
type ImplicitNodes struct {
|
||||
beg, end int
|
||||
curr int
|
||||
newNode func(id int) graph.Node
|
||||
}
|
||||
|
||||
// NewImplicitNodes returns a new implicit node iterator spanning nodes in [beg,end).
|
||||
// The provided new func maps the id to a graph.Node. NewImplicitNodes will panic
|
||||
// if beg is greater than end.
|
||||
func NewImplicitNodes(beg, end int, new func(id int) graph.Node) *ImplicitNodes {
|
||||
if beg > end {
|
||||
panic("iterator: invalid range")
|
||||
}
|
||||
return &ImplicitNodes{beg: beg, end: end, curr: beg - 1, newNode: new}
|
||||
}
|
||||
|
||||
// Len returns the remaining number of nodes to be iterated over.
|
||||
func (n *ImplicitNodes) Len() int {
|
||||
return n.end - n.curr - 1
|
||||
}
|
||||
|
||||
// Next returns whether the next call of Node will return a valid node.
|
||||
func (n *ImplicitNodes) Next() bool {
|
||||
if n.curr == n.end {
|
||||
return false
|
||||
}
|
||||
n.curr++
|
||||
return n.curr < n.end
|
||||
}
|
||||
|
||||
// Node returns the current node of the iterator. Next must have been
|
||||
// called prior to a call to Node.
|
||||
func (n *ImplicitNodes) Node() graph.Node {
|
||||
if n.Len() == -1 || n.curr < n.beg {
|
||||
return nil
|
||||
}
|
||||
return n.newNode(n.curr)
|
||||
}
|
||||
|
||||
// Reset returns the iterator to its initial state.
|
||||
func (n *ImplicitNodes) Reset() {
|
||||
n.curr = n.beg - 1
|
||||
}
|
||||
|
||||
// NodeSlice returns all the remaining nodes in the iterator and advances
|
||||
// the iterator.
|
||||
func (n *ImplicitNodes) NodeSlice() []graph.Node {
|
||||
nodes := make([]graph.Node, 0, n.Len())
|
||||
for n.curr++; n.curr < n.end; n.curr++ {
|
||||
nodes = append(nodes, n.newNode(n.curr))
|
||||
}
|
||||
return nodes
|
||||
}
|
||||
198
vendor/gonum.org/v1/gonum/graph/multigraph.go
generated
vendored
Normal file
198
vendor/gonum.org/v1/gonum/graph/multigraph.go
generated
vendored
Normal file
@@ -0,0 +1,198 @@
|
||||
// Copyright ©2014 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package graph
|
||||
|
||||
// Line is an edge in a multigraph. A Line returns an ID that must
|
||||
// distinguish Lines sharing Node end points.
|
||||
type Line interface {
|
||||
// From returns the from node of the edge.
|
||||
From() Node
|
||||
|
||||
// To returns the to node of the edge.
|
||||
To() Node
|
||||
|
||||
// ReversedLine returns a line that has the
|
||||
// end points of the receiver swapped.
|
||||
ReversedLine() Line
|
||||
|
||||
// ID returns the unique ID for the Line.
|
||||
ID() int64
|
||||
}
|
||||
|
||||
// WeightedLine is a weighted multigraph edge.
|
||||
type WeightedLine interface {
|
||||
Line
|
||||
Weight() float64
|
||||
}
|
||||
|
||||
// Multigraph is a generalized multigraph.
|
||||
type Multigraph interface {
|
||||
// Node returns the node with the given ID if it exists
|
||||
// in the multigraph, and nil otherwise.
|
||||
Node(id int64) Node
|
||||
|
||||
// Nodes returns all the nodes in the multigraph.
|
||||
//
|
||||
// Nodes must not return nil.
|
||||
Nodes() Nodes
|
||||
|
||||
// From returns all nodes that can be reached directly
|
||||
// from the node with the given ID.
|
||||
//
|
||||
// From must not return nil.
|
||||
From(id int64) Nodes
|
||||
|
||||
// HasEdgeBetween returns whether an edge exists between
|
||||
// nodes with IDs xid and yid without considering direction.
|
||||
HasEdgeBetween(xid, yid int64) bool
|
||||
|
||||
// Lines returns the lines from u to v, with IDs uid and
|
||||
// vid, if any such lines exist and nil otherwise. The
|
||||
// node v must be directly reachable from u as defined by
|
||||
// the From method.
|
||||
//
|
||||
// Lines must not return nil.
|
||||
Lines(uid, vid int64) Lines
|
||||
}
|
||||
|
||||
// WeightedMultigraph is a weighted multigraph.
|
||||
type WeightedMultigraph interface {
|
||||
Multigraph
|
||||
|
||||
// WeightedLines returns the weighted lines from u to v
|
||||
// with IDs uid and vid if any such lines exist and nil
|
||||
// otherwise. The node v must be directly reachable
|
||||
// from u as defined by the From method.
|
||||
//
|
||||
// WeightedLines must not return nil.
|
||||
WeightedLines(uid, vid int64) WeightedLines
|
||||
}
|
||||
|
||||
// UndirectedMultigraph is an undirected multigraph.
|
||||
type UndirectedMultigraph interface {
|
||||
Multigraph
|
||||
|
||||
// LinesBetween returns the lines between nodes x and y
|
||||
// with IDs xid and yid.
|
||||
//
|
||||
// LinesBetween must not return nil.
|
||||
LinesBetween(xid, yid int64) Lines
|
||||
}
|
||||
|
||||
// WeightedUndirectedMultigraph is a weighted undirected multigraph.
|
||||
type WeightedUndirectedMultigraph interface {
|
||||
WeightedMultigraph
|
||||
|
||||
// WeightedLinesBetween returns the lines between nodes
|
||||
// x and y with IDs xid and yid.
|
||||
//
|
||||
// WeightedLinesBetween must not return nil.
|
||||
WeightedLinesBetween(xid, yid int64) WeightedLines
|
||||
}
|
||||
|
||||
// DirectedMultigraph is a directed multigraph.
|
||||
type DirectedMultigraph interface {
|
||||
Multigraph
|
||||
|
||||
// HasEdgeFromTo returns whether an edge exists
|
||||
// in the multigraph from u to v with IDs uid
|
||||
// and vid.
|
||||
HasEdgeFromTo(uid, vid int64) bool
|
||||
|
||||
// To returns all nodes that can reach directly
|
||||
// to the node with the given ID.
|
||||
//
|
||||
// To must not return nil.
|
||||
To(id int64) Nodes
|
||||
}
|
||||
|
||||
// WeightedDirectedMultigraph is a weighted directed multigraph.
|
||||
type WeightedDirectedMultigraph interface {
|
||||
WeightedMultigraph
|
||||
|
||||
// HasEdgeFromTo returns whether an edge exists
|
||||
// in the multigraph from u to v with IDs uid
|
||||
// and vid.
|
||||
HasEdgeFromTo(uid, vid int64) bool
|
||||
|
||||
// To returns all nodes that can reach directly
|
||||
// to the node with the given ID.
|
||||
//
|
||||
// To must not return nil.
|
||||
To(id int64) Nodes
|
||||
}
|
||||
|
||||
// LineAdder is an interface for adding lines to a multigraph.
|
||||
type LineAdder interface {
|
||||
// NewLine returns a new Line from the source to the destination node.
|
||||
NewLine(from, to Node) Line
|
||||
|
||||
// SetLine adds a Line from one node to another.
|
||||
// If the multigraph supports node addition the nodes
|
||||
// will be added if they do not exist, otherwise
|
||||
// SetLine will panic.
|
||||
// Whether l, l.From() and l.To() are stored
|
||||
// within the graph is implementation dependent.
|
||||
SetLine(l Line)
|
||||
}
|
||||
|
||||
// WeightedLineAdder is an interface for adding lines to a multigraph.
|
||||
type WeightedLineAdder interface {
|
||||
// NewWeightedLine returns a new WeightedLine from
|
||||
// the source to the destination node.
|
||||
NewWeightedLine(from, to Node, weight float64) WeightedLine
|
||||
|
||||
// SetWeightedLine adds a weighted line from one node
|
||||
// to another. If the multigraph supports node addition
|
||||
// the nodes will be added if they do not exist,
|
||||
// otherwise SetWeightedLine will panic.
|
||||
// Whether l, l.From() and l.To() are stored
|
||||
// within the graph is implementation dependent.
|
||||
SetWeightedLine(l WeightedLine)
|
||||
}
|
||||
|
||||
// LineRemover is an interface for removing lines from a multigraph.
|
||||
type LineRemover interface {
|
||||
// RemoveLine removes the line with the given end
|
||||
// and line IDs, leaving the terminal nodes. If
|
||||
// the line does not exist it is a no-op.
|
||||
RemoveLine(fid, tid, id int64)
|
||||
}
|
||||
|
||||
// MultigraphBuilder is a multigraph that can have nodes and lines added.
|
||||
type MultigraphBuilder interface {
|
||||
NodeAdder
|
||||
LineAdder
|
||||
}
|
||||
|
||||
// WeightedMultigraphBuilder is a multigraph that can have nodes and weighted lines added.
|
||||
type WeightedMultigraphBuilder interface {
|
||||
NodeAdder
|
||||
WeightedLineAdder
|
||||
}
|
||||
|
||||
// UndirectedMultgraphBuilder is an undirected multigraph builder.
|
||||
type UndirectedMultigraphBuilder interface {
|
||||
UndirectedMultigraph
|
||||
MultigraphBuilder
|
||||
}
|
||||
|
||||
// UndirectedWeightedMultigraphBuilder is an undirected weighted multigraph builder.
|
||||
type UndirectedWeightedMultigraphBuilder interface {
|
||||
UndirectedMultigraph
|
||||
WeightedMultigraphBuilder
|
||||
}
|
||||
|
||||
// DirectedMultigraphBuilder is a directed multigraph builder.
|
||||
type DirectedMultigraphBuilder interface {
|
||||
DirectedMultigraph
|
||||
MultigraphBuilder
|
||||
}
|
||||
|
||||
// DirectedWeightedMultigraphBuilder is a directed weighted multigraph builder.
|
||||
type DirectedWeightedMultigraphBuilder interface {
|
||||
DirectedMultigraph
|
||||
WeightedMultigraphBuilder
|
||||
}
|
||||
300
vendor/gonum.org/v1/gonum/graph/nodes_edges.go
generated
vendored
Normal file
300
vendor/gonum.org/v1/gonum/graph/nodes_edges.go
generated
vendored
Normal file
@@ -0,0 +1,300 @@
|
||||
// Copyright ©2018 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package graph
|
||||
|
||||
// Iterator is an item iterator.
|
||||
type Iterator interface {
|
||||
// Next advances the iterator and returns whether
|
||||
// the next call to the item method will return a
|
||||
// non-nil item.
|
||||
//
|
||||
// Next should be called prior to any call to the
|
||||
// iterator's item retrieval method after the
|
||||
// iterator has been obtained or reset.
|
||||
//
|
||||
// The order of iteration is implementation
|
||||
// dependent.
|
||||
Next() bool
|
||||
|
||||
// Len returns the number of items remaining in the
|
||||
// iterator.
|
||||
//
|
||||
// If the number of items in the iterator is unknown,
|
||||
// too large to materialize or too costly to calculate
|
||||
// then Len may return a negative value.
|
||||
// In this case the consuming function must be able
|
||||
// to operate on the items of the iterator directly
|
||||
// without materializing the items into a slice.
|
||||
// The magnitude of a negative length has
|
||||
// implementation-dependent semantics.
|
||||
Len() int
|
||||
|
||||
// Reset returns the iterator to its start position.
|
||||
Reset()
|
||||
}
|
||||
|
||||
// Nodes is a Node iterator.
|
||||
type Nodes interface {
|
||||
Iterator
|
||||
|
||||
// Node returns the current Node from the iterator.
|
||||
Node() Node
|
||||
}
|
||||
|
||||
// NodeSlicer wraps the NodeSlice method.
|
||||
type NodeSlicer interface {
|
||||
// NodeSlice returns the set of nodes remaining
|
||||
// to be iterated by a Nodes iterator.
|
||||
// The holder of the iterator may arbitrarily
|
||||
// change elements in the returned slice, but
|
||||
// those changes may be reflected to other
|
||||
// iterators.
|
||||
NodeSlice() []Node
|
||||
}
|
||||
|
||||
// NodesOf returns it.Len() nodes from it. If it is a NodeSlicer, the NodeSlice method
|
||||
// is used to obtain the nodes. It is safe to pass a nil Nodes to NodesOf.
|
||||
//
|
||||
// If the Nodes has an indeterminate length, NodesOf will panic.
|
||||
func NodesOf(it Nodes) []Node {
|
||||
if it == nil {
|
||||
return nil
|
||||
}
|
||||
len := it.Len()
|
||||
switch {
|
||||
case len == 0:
|
||||
return nil
|
||||
case len < 0:
|
||||
panic("graph: called NodesOf on indeterminate iterator")
|
||||
}
|
||||
switch it := it.(type) {
|
||||
case NodeSlicer:
|
||||
return it.NodeSlice()
|
||||
}
|
||||
n := make([]Node, 0, len)
|
||||
for it.Next() {
|
||||
n = append(n, it.Node())
|
||||
}
|
||||
return n
|
||||
}
|
||||
|
||||
// Edges is an Edge iterator.
|
||||
type Edges interface {
|
||||
Iterator
|
||||
|
||||
// Edge returns the current Edge from the iterator.
|
||||
Edge() Edge
|
||||
}
|
||||
|
||||
// EdgeSlicer wraps the EdgeSlice method.
|
||||
type EdgeSlicer interface {
|
||||
// EdgeSlice returns the set of edges remaining
|
||||
// to be iterated by an Edges iterator.
|
||||
// The holder of the iterator may arbitrarily
|
||||
// change elements in the returned slice, but
|
||||
// those changes may be reflected to other
|
||||
// iterators.
|
||||
EdgeSlice() []Edge
|
||||
}
|
||||
|
||||
// EdgesOf returns it.Len() nodes from it. If it is an EdgeSlicer, the EdgeSlice method is used
|
||||
// to obtain the edges. It is safe to pass a nil Edges to EdgesOf.
|
||||
//
|
||||
// If the Edges has an indeterminate length, EdgesOf will panic.
|
||||
func EdgesOf(it Edges) []Edge {
|
||||
if it == nil {
|
||||
return nil
|
||||
}
|
||||
len := it.Len()
|
||||
switch {
|
||||
case len == 0:
|
||||
return nil
|
||||
case len < 0:
|
||||
panic("graph: called EdgesOf on indeterminate iterator")
|
||||
}
|
||||
switch it := it.(type) {
|
||||
case EdgeSlicer:
|
||||
return it.EdgeSlice()
|
||||
}
|
||||
e := make([]Edge, 0, len)
|
||||
for it.Next() {
|
||||
e = append(e, it.Edge())
|
||||
}
|
||||
return e
|
||||
}
|
||||
|
||||
// WeightedEdges is a WeightedEdge iterator.
|
||||
type WeightedEdges interface {
|
||||
Iterator
|
||||
|
||||
// Edge returns the current Edge from the iterator.
|
||||
WeightedEdge() WeightedEdge
|
||||
}
|
||||
|
||||
// WeightedEdgeSlicer wraps the WeightedEdgeSlice method.
|
||||
type WeightedEdgeSlicer interface {
|
||||
// EdgeSlice returns the set of edges remaining
|
||||
// to be iterated by an Edges iterator.
|
||||
// The holder of the iterator may arbitrarily
|
||||
// change elements in the returned slice, but
|
||||
// those changes may be reflected to other
|
||||
// iterators.
|
||||
WeightedEdgeSlice() []WeightedEdge
|
||||
}
|
||||
|
||||
// WeightedEdgesOf returns it.Len() weighted edge from it. If it is a WeightedEdgeSlicer, the
|
||||
// WeightedEdgeSlice method is used to obtain the edges. It is safe to pass a nil WeightedEdges
|
||||
// to WeightedEdgesOf.
|
||||
//
|
||||
// If the WeightedEdges has an indeterminate length, WeightedEdgesOf will panic.
|
||||
func WeightedEdgesOf(it WeightedEdges) []WeightedEdge {
|
||||
if it == nil {
|
||||
return nil
|
||||
}
|
||||
len := it.Len()
|
||||
switch {
|
||||
case len == 0:
|
||||
return nil
|
||||
case len < 0:
|
||||
panic("graph: called WeightedEdgesOf on indeterminate iterator")
|
||||
}
|
||||
switch it := it.(type) {
|
||||
case WeightedEdgeSlicer:
|
||||
return it.WeightedEdgeSlice()
|
||||
}
|
||||
e := make([]WeightedEdge, 0, len)
|
||||
for it.Next() {
|
||||
e = append(e, it.WeightedEdge())
|
||||
}
|
||||
return e
|
||||
}
|
||||
|
||||
// Lines is a Line iterator.
|
||||
type Lines interface {
|
||||
Iterator
|
||||
|
||||
// Line returns the current Line from the iterator.
|
||||
Line() Line
|
||||
}
|
||||
|
||||
// LineSlicer wraps the LineSlice method.
|
||||
type LineSlicer interface {
|
||||
// LineSlice returns the set of lines remaining
|
||||
// to be iterated by an Lines iterator.
|
||||
// The holder of the iterator may arbitrarily
|
||||
// change elements in the returned slice, but
|
||||
// those changes may be reflected to other
|
||||
// iterators.
|
||||
LineSlice() []Line
|
||||
}
|
||||
|
||||
// LinesOf returns it.Len() nodes from it. If it is a LineSlicer, the LineSlice method is used
|
||||
// to obtain the lines. It is safe to pass a nil Lines to LinesOf.
|
||||
//
|
||||
// If the Lines has an indeterminate length, LinesOf will panic.
|
||||
func LinesOf(it Lines) []Line {
|
||||
if it == nil {
|
||||
return nil
|
||||
}
|
||||
len := it.Len()
|
||||
switch {
|
||||
case len == 0:
|
||||
return nil
|
||||
case len < 0:
|
||||
panic("graph: called LinesOf on indeterminate iterator")
|
||||
}
|
||||
switch it := it.(type) {
|
||||
case LineSlicer:
|
||||
return it.LineSlice()
|
||||
}
|
||||
l := make([]Line, 0, len)
|
||||
for it.Next() {
|
||||
l = append(l, it.Line())
|
||||
}
|
||||
return l
|
||||
}
|
||||
|
||||
// WeightedLines is a WeightedLine iterator.
|
||||
type WeightedLines interface {
|
||||
Iterator
|
||||
|
||||
// Line returns the current Line from the iterator.
|
||||
WeightedLine() WeightedLine
|
||||
}
|
||||
|
||||
// WeightedLineSlicer wraps the WeightedLineSlice method.
|
||||
type WeightedLineSlicer interface {
|
||||
// LineSlice returns the set of lines remaining
|
||||
// to be iterated by an Lines iterator.
|
||||
// The holder of the iterator may arbitrarily
|
||||
// change elements in the returned slice, but
|
||||
// those changes may be reflected to other
|
||||
// iterators.
|
||||
WeightedLineSlice() []WeightedLine
|
||||
}
|
||||
|
||||
// WeightedLinesOf returns it.Len() weighted line from it. If it is a WeightedLineSlicer, the
|
||||
// WeightedLineSlice method is used to obtain the lines. It is safe to pass a nil WeightedLines
|
||||
// to WeightedLinesOf.
|
||||
//
|
||||
// If the WeightedLines has an indeterminate length, WeightedLinesOf will panic.
|
||||
func WeightedLinesOf(it WeightedLines) []WeightedLine {
|
||||
if it == nil {
|
||||
return nil
|
||||
}
|
||||
len := it.Len()
|
||||
switch {
|
||||
case len == 0:
|
||||
return nil
|
||||
case len < 0:
|
||||
panic("graph: called WeightedLinesOf on indeterminate iterator")
|
||||
}
|
||||
switch it := it.(type) {
|
||||
case WeightedLineSlicer:
|
||||
return it.WeightedLineSlice()
|
||||
}
|
||||
l := make([]WeightedLine, 0, len)
|
||||
for it.Next() {
|
||||
l = append(l, it.WeightedLine())
|
||||
}
|
||||
return l
|
||||
}
|
||||
|
||||
// Empty is an empty set of nodes, edges or lines. It should be used when
|
||||
// a graph returns a zero-length Iterator. Empty implements the slicer
|
||||
// interfaces for nodes, edges and lines, returning nil for each of these.
|
||||
const Empty = nothing
|
||||
|
||||
var (
|
||||
_ Iterator = Empty
|
||||
_ Nodes = Empty
|
||||
_ NodeSlicer = Empty
|
||||
_ Edges = Empty
|
||||
_ EdgeSlicer = Empty
|
||||
_ WeightedEdges = Empty
|
||||
_ WeightedEdgeSlicer = Empty
|
||||
_ Lines = Empty
|
||||
_ LineSlicer = Empty
|
||||
_ WeightedLines = Empty
|
||||
_ WeightedLineSlicer = Empty
|
||||
)
|
||||
|
||||
const nothing = empty(true)
|
||||
|
||||
type empty bool
|
||||
|
||||
func (empty) Next() bool { return false }
|
||||
func (empty) Len() int { return 0 }
|
||||
func (empty) Reset() {}
|
||||
func (empty) Node() Node { return nil }
|
||||
func (empty) NodeSlice() []Node { return nil }
|
||||
func (empty) Edge() Edge { return nil }
|
||||
func (empty) EdgeSlice() []Edge { return nil }
|
||||
func (empty) WeightedEdge() WeightedEdge { return nil }
|
||||
func (empty) WeightedEdgeSlice() []WeightedEdge { return nil }
|
||||
func (empty) Line() Line { return nil }
|
||||
func (empty) LineSlice() []Line { return nil }
|
||||
func (empty) WeightedLine() WeightedLine { return nil }
|
||||
func (empty) WeightedLineSlice() []WeightedLine { return nil }
|
||||
301
vendor/gonum.org/v1/gonum/graph/simple/dense_directed_matrix.go
generated
vendored
Normal file
301
vendor/gonum.org/v1/gonum/graph/simple/dense_directed_matrix.go
generated
vendored
Normal file
@@ -0,0 +1,301 @@
|
||||
// Copyright ©2014 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package simple
|
||||
|
||||
import (
|
||||
"sort"
|
||||
|
||||
"gonum.org/v1/gonum/graph"
|
||||
"gonum.org/v1/gonum/graph/internal/ordered"
|
||||
"gonum.org/v1/gonum/graph/iterator"
|
||||
"gonum.org/v1/gonum/mat"
|
||||
)
|
||||
|
||||
var (
|
||||
dm *DirectedMatrix
|
||||
|
||||
_ graph.Graph = dm
|
||||
_ graph.Directed = dm
|
||||
_ edgeSetter = dm
|
||||
_ weightedEdgeSetter = dm
|
||||
)
|
||||
|
||||
// DirectedMatrix represents a directed graph using an adjacency
|
||||
// matrix such that all IDs are in a contiguous block from 0 to n-1.
|
||||
// Edges are stored implicitly as an edge weight, so edges stored in
|
||||
// the graph are not recoverable.
|
||||
type DirectedMatrix struct {
|
||||
mat *mat.Dense
|
||||
nodes []graph.Node
|
||||
|
||||
self float64
|
||||
absent float64
|
||||
}
|
||||
|
||||
// NewDirectedMatrix creates a directed dense graph with n nodes.
|
||||
// All edges are initialized with the weight given by init. The self parameter
|
||||
// specifies the cost of self connection, and absent specifies the weight
|
||||
// returned for absent edges.
|
||||
func NewDirectedMatrix(n int, init, self, absent float64) *DirectedMatrix {
|
||||
matrix := make([]float64, n*n)
|
||||
if init != 0 {
|
||||
for i := range matrix {
|
||||
matrix[i] = init
|
||||
}
|
||||
}
|
||||
for i := 0; i < len(matrix); i += n + 1 {
|
||||
matrix[i] = self
|
||||
}
|
||||
return &DirectedMatrix{
|
||||
mat: mat.NewDense(n, n, matrix),
|
||||
self: self,
|
||||
absent: absent,
|
||||
}
|
||||
}
|
||||
|
||||
// NewDirectedMatrixFrom creates a directed dense graph with the given nodes.
|
||||
// The IDs of the nodes must be contiguous from 0 to len(nodes)-1, but may
|
||||
// be in any order. If IDs are not contiguous NewDirectedMatrixFrom will panic.
|
||||
// All edges are initialized with the weight given by init. The self parameter
|
||||
// specifies the cost of self connection, and absent specifies the weight
|
||||
// returned for absent edges.
|
||||
func NewDirectedMatrixFrom(nodes []graph.Node, init, self, absent float64) *DirectedMatrix {
|
||||
sort.Sort(ordered.ByID(nodes))
|
||||
for i, n := range nodes {
|
||||
if int64(i) != n.ID() {
|
||||
panic("simple: non-contiguous node IDs")
|
||||
}
|
||||
}
|
||||
g := NewDirectedMatrix(len(nodes), init, self, absent)
|
||||
g.nodes = nodes
|
||||
return g
|
||||
}
|
||||
|
||||
// Edge returns the edge from u to v if such an edge exists and nil otherwise.
|
||||
// The node v must be directly reachable from u as defined by the From method.
|
||||
func (g *DirectedMatrix) Edge(uid, vid int64) graph.Edge {
|
||||
return g.WeightedEdge(uid, vid)
|
||||
}
|
||||
|
||||
// Edges returns all the edges in the graph.
|
||||
func (g *DirectedMatrix) Edges() graph.Edges {
|
||||
var edges []graph.Edge
|
||||
r, _ := g.mat.Dims()
|
||||
for i := 0; i < r; i++ {
|
||||
for j := 0; j < r; j++ {
|
||||
if i == j {
|
||||
continue
|
||||
}
|
||||
if w := g.mat.At(i, j); !isSame(w, g.absent) {
|
||||
edges = append(edges, WeightedEdge{F: g.Node(int64(i)), T: g.Node(int64(j)), W: w})
|
||||
}
|
||||
}
|
||||
}
|
||||
if len(edges) == 0 {
|
||||
return graph.Empty
|
||||
}
|
||||
return iterator.NewOrderedEdges(edges)
|
||||
}
|
||||
|
||||
// From returns all nodes in g that can be reached directly from n.
|
||||
func (g *DirectedMatrix) From(id int64) graph.Nodes {
|
||||
if !g.has(id) {
|
||||
return graph.Empty
|
||||
}
|
||||
var nodes []graph.Node
|
||||
_, c := g.mat.Dims()
|
||||
for j := 0; j < c; j++ {
|
||||
if int64(j) == id {
|
||||
continue
|
||||
}
|
||||
// id is not greater than maximum int by this point.
|
||||
if !isSame(g.mat.At(int(id), j), g.absent) {
|
||||
nodes = append(nodes, g.Node(int64(j)))
|
||||
}
|
||||
}
|
||||
if len(nodes) == 0 {
|
||||
return graph.Empty
|
||||
}
|
||||
return iterator.NewOrderedNodes(nodes)
|
||||
}
|
||||
|
||||
// HasEdgeBetween returns whether an edge exists between nodes x and y without
|
||||
// considering direction.
|
||||
func (g *DirectedMatrix) HasEdgeBetween(xid, yid int64) bool {
|
||||
if !g.has(xid) {
|
||||
return false
|
||||
}
|
||||
if !g.has(yid) {
|
||||
return false
|
||||
}
|
||||
// xid and yid are not greater than maximum int by this point.
|
||||
return xid != yid && (!isSame(g.mat.At(int(xid), int(yid)), g.absent) || !isSame(g.mat.At(int(yid), int(xid)), g.absent))
|
||||
}
|
||||
|
||||
// HasEdgeFromTo returns whether an edge exists in the graph from u to v.
|
||||
func (g *DirectedMatrix) HasEdgeFromTo(uid, vid int64) bool {
|
||||
if !g.has(uid) {
|
||||
return false
|
||||
}
|
||||
if !g.has(vid) {
|
||||
return false
|
||||
}
|
||||
// uid and vid are not greater than maximum int by this point.
|
||||
return uid != vid && !isSame(g.mat.At(int(uid), int(vid)), g.absent)
|
||||
}
|
||||
|
||||
// Matrix returns the mat.Matrix representation of the graph. The orientation
|
||||
// of the matrix is such that the matrix entry at G_{ij} is the weight of the edge
|
||||
// from node i to node j.
|
||||
func (g *DirectedMatrix) Matrix() mat.Matrix {
|
||||
// Prevent alteration of dimensions of the returned matrix.
|
||||
m := *g.mat
|
||||
return &m
|
||||
}
|
||||
|
||||
// Node returns the node with the given ID if it exists in the graph,
|
||||
// and nil otherwise.
|
||||
func (g *DirectedMatrix) Node(id int64) graph.Node {
|
||||
if !g.has(id) {
|
||||
return nil
|
||||
}
|
||||
if g.nodes == nil {
|
||||
return Node(id)
|
||||
}
|
||||
return g.nodes[id]
|
||||
}
|
||||
|
||||
// Nodes returns all the nodes in the graph.
|
||||
func (g *DirectedMatrix) Nodes() graph.Nodes {
|
||||
if g.nodes != nil {
|
||||
nodes := make([]graph.Node, len(g.nodes))
|
||||
copy(nodes, g.nodes)
|
||||
return iterator.NewOrderedNodes(nodes)
|
||||
}
|
||||
r, _ := g.mat.Dims()
|
||||
// Matrix graphs must have at least one node.
|
||||
return iterator.NewImplicitNodes(0, r, newSimpleNode)
|
||||
}
|
||||
|
||||
// RemoveEdge removes the edge with the given end point nodes from the graph, leaving the terminal
|
||||
// nodes. If the edge does not exist it is a no-op.
|
||||
func (g *DirectedMatrix) RemoveEdge(fid, tid int64) {
|
||||
if !g.has(fid) {
|
||||
return
|
||||
}
|
||||
if !g.has(tid) {
|
||||
return
|
||||
}
|
||||
// fid and tid are not greater than maximum int by this point.
|
||||
g.mat.Set(int(fid), int(tid), g.absent)
|
||||
}
|
||||
|
||||
// SetEdge sets e, an edge from one node to another with unit weight. If the ends of the edge
|
||||
// are not in g or the edge is a self loop, SetEdge panics. SetEdge will store the nodes of
|
||||
// e in the graph if it was initialized with NewDirectedMatrixFrom.
|
||||
func (g *DirectedMatrix) SetEdge(e graph.Edge) {
|
||||
g.setWeightedEdge(e, 1)
|
||||
}
|
||||
|
||||
// SetWeightedEdge sets e, an edge from one node to another. If the ends of the edge are not in g
|
||||
// or the edge is a self loop, SetWeightedEdge panics. SetWeightedEdge will store the nodes of
|
||||
// e in the graph if it was initialized with NewDirectedMatrixFrom.
|
||||
func (g *DirectedMatrix) SetWeightedEdge(e graph.WeightedEdge) {
|
||||
g.setWeightedEdge(e, e.Weight())
|
||||
}
|
||||
|
||||
func (g *DirectedMatrix) setWeightedEdge(e graph.Edge, weight float64) {
|
||||
from := e.From()
|
||||
fid := from.ID()
|
||||
to := e.To()
|
||||
tid := to.ID()
|
||||
if fid == tid {
|
||||
panic("simple: set illegal edge")
|
||||
}
|
||||
if int64(int(fid)) != fid {
|
||||
panic("simple: unavailable from node ID for dense graph")
|
||||
}
|
||||
if int64(int(tid)) != tid {
|
||||
panic("simple: unavailable to node ID for dense graph")
|
||||
}
|
||||
if g.nodes != nil {
|
||||
g.nodes[fid] = from
|
||||
g.nodes[tid] = to
|
||||
}
|
||||
// fid and tid are not greater than maximum int by this point.
|
||||
g.mat.Set(int(fid), int(tid), weight)
|
||||
}
|
||||
|
||||
// To returns all nodes in g that can reach directly to n.
|
||||
func (g *DirectedMatrix) To(id int64) graph.Nodes {
|
||||
if !g.has(id) {
|
||||
return graph.Empty
|
||||
}
|
||||
var nodes []graph.Node
|
||||
r, _ := g.mat.Dims()
|
||||
for i := 0; i < r; i++ {
|
||||
if int64(i) == id {
|
||||
continue
|
||||
}
|
||||
// id is not greater than maximum int by this point.
|
||||
if !isSame(g.mat.At(i, int(id)), g.absent) {
|
||||
nodes = append(nodes, g.Node(int64(i)))
|
||||
}
|
||||
}
|
||||
if len(nodes) == 0 {
|
||||
return graph.Empty
|
||||
}
|
||||
return iterator.NewOrderedNodes(nodes)
|
||||
}
|
||||
|
||||
// Weight returns the weight for the edge between x and y if Edge(x, y) returns a non-nil Edge.
|
||||
// If x and y are the same node or there is no joining edge between the two nodes the weight
|
||||
// value returned is either the graph's absent or self value. Weight returns true if an edge
|
||||
// exists between x and y or if x and y have the same ID, false otherwise.
|
||||
func (g *DirectedMatrix) Weight(xid, yid int64) (w float64, ok bool) {
|
||||
if xid == yid {
|
||||
return g.self, true
|
||||
}
|
||||
if g.HasEdgeFromTo(xid, yid) {
|
||||
// xid and yid are not greater than maximum int by this point.
|
||||
return g.mat.At(int(xid), int(yid)), true
|
||||
}
|
||||
return g.absent, false
|
||||
}
|
||||
|
||||
// WeightedEdge returns the weighted edge from u to v if such an edge exists and nil otherwise.
|
||||
// The node v must be directly reachable from u as defined by the From method.
|
||||
func (g *DirectedMatrix) WeightedEdge(uid, vid int64) graph.WeightedEdge {
|
||||
if g.HasEdgeFromTo(uid, vid) {
|
||||
// xid and yid are not greater than maximum int by this point.
|
||||
return WeightedEdge{F: g.Node(uid), T: g.Node(vid), W: g.mat.At(int(uid), int(vid))}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// WeightedEdges returns all the edges in the graph.
|
||||
func (g *DirectedMatrix) WeightedEdges() graph.WeightedEdges {
|
||||
var edges []graph.WeightedEdge
|
||||
r, _ := g.mat.Dims()
|
||||
for i := 0; i < r; i++ {
|
||||
for j := 0; j < r; j++ {
|
||||
if i == j {
|
||||
continue
|
||||
}
|
||||
if w := g.mat.At(i, j); !isSame(w, g.absent) {
|
||||
edges = append(edges, WeightedEdge{F: g.Node(int64(i)), T: g.Node(int64(j)), W: w})
|
||||
}
|
||||
}
|
||||
}
|
||||
if len(edges) == 0 {
|
||||
return graph.Empty
|
||||
}
|
||||
return iterator.NewOrderedWeightedEdges(edges)
|
||||
}
|
||||
|
||||
func (g *DirectedMatrix) has(id int64) bool {
|
||||
r, _ := g.mat.Dims()
|
||||
return 0 <= id && id < int64(r)
|
||||
}
|
||||
268
vendor/gonum.org/v1/gonum/graph/simple/dense_undirected_matrix.go
generated
vendored
Normal file
268
vendor/gonum.org/v1/gonum/graph/simple/dense_undirected_matrix.go
generated
vendored
Normal file
@@ -0,0 +1,268 @@
|
||||
// Copyright ©2014 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package simple
|
||||
|
||||
import (
|
||||
"sort"
|
||||
|
||||
"gonum.org/v1/gonum/graph"
|
||||
"gonum.org/v1/gonum/graph/internal/ordered"
|
||||
"gonum.org/v1/gonum/graph/iterator"
|
||||
"gonum.org/v1/gonum/mat"
|
||||
)
|
||||
|
||||
var (
|
||||
um *UndirectedMatrix
|
||||
|
||||
_ graph.Graph = um
|
||||
_ graph.Undirected = um
|
||||
_ edgeSetter = um
|
||||
_ weightedEdgeSetter = um
|
||||
)
|
||||
|
||||
// UndirectedMatrix represents an undirected graph using an adjacency
|
||||
// matrix such that all IDs are in a contiguous block from 0 to n-1.
|
||||
// Edges are stored implicitly as an edge weight, so edges stored in
|
||||
// the graph are not recoverable.
|
||||
type UndirectedMatrix struct {
|
||||
mat *mat.SymDense
|
||||
nodes []graph.Node
|
||||
|
||||
self float64
|
||||
absent float64
|
||||
}
|
||||
|
||||
// NewUndirectedMatrix creates an undirected dense graph with n nodes.
|
||||
// All edges are initialized with the weight given by init. The self parameter
|
||||
// specifies the cost of self connection, and absent specifies the weight
|
||||
// returned for absent edges.
|
||||
func NewUndirectedMatrix(n int, init, self, absent float64) *UndirectedMatrix {
|
||||
matrix := make([]float64, n*n)
|
||||
if init != 0 {
|
||||
for i := range matrix {
|
||||
matrix[i] = init
|
||||
}
|
||||
}
|
||||
for i := 0; i < len(matrix); i += n + 1 {
|
||||
matrix[i] = self
|
||||
}
|
||||
return &UndirectedMatrix{
|
||||
mat: mat.NewSymDense(n, matrix),
|
||||
self: self,
|
||||
absent: absent,
|
||||
}
|
||||
}
|
||||
|
||||
// NewUndirectedMatrixFrom creates an undirected dense graph with the given nodes.
|
||||
// The IDs of the nodes must be contiguous from 0 to len(nodes)-1, but may
|
||||
// be in any order. If IDs are not contiguous NewUndirectedMatrixFrom will panic.
|
||||
// All edges are initialized with the weight given by init. The self parameter
|
||||
// specifies the cost of self connection, and absent specifies the weight
|
||||
// returned for absent edges.
|
||||
func NewUndirectedMatrixFrom(nodes []graph.Node, init, self, absent float64) *UndirectedMatrix {
|
||||
sort.Sort(ordered.ByID(nodes))
|
||||
for i, n := range nodes {
|
||||
if int64(i) != n.ID() {
|
||||
panic("simple: non-contiguous node IDs")
|
||||
}
|
||||
}
|
||||
g := NewUndirectedMatrix(len(nodes), init, self, absent)
|
||||
g.nodes = nodes
|
||||
return g
|
||||
}
|
||||
|
||||
// Edge returns the edge from u to v if such an edge exists and nil otherwise.
|
||||
// The node v must be directly reachable from u as defined by the From method.
|
||||
func (g *UndirectedMatrix) Edge(uid, vid int64) graph.Edge {
|
||||
return g.WeightedEdgeBetween(uid, vid)
|
||||
}
|
||||
|
||||
// EdgeBetween returns the edge between nodes x and y.
|
||||
func (g *UndirectedMatrix) EdgeBetween(uid, vid int64) graph.Edge {
|
||||
return g.WeightedEdgeBetween(uid, vid)
|
||||
}
|
||||
|
||||
// Edges returns all the edges in the graph.
|
||||
func (g *UndirectedMatrix) Edges() graph.Edges {
|
||||
var edges []graph.Edge
|
||||
r, _ := g.mat.Dims()
|
||||
for i := 0; i < r; i++ {
|
||||
for j := i + 1; j < r; j++ {
|
||||
if w := g.mat.At(i, j); !isSame(w, g.absent) {
|
||||
edges = append(edges, WeightedEdge{F: g.Node(int64(i)), T: g.Node(int64(j)), W: w})
|
||||
}
|
||||
}
|
||||
}
|
||||
if len(edges) == 0 {
|
||||
return graph.Empty
|
||||
}
|
||||
return iterator.NewOrderedEdges(edges)
|
||||
}
|
||||
|
||||
// From returns all nodes in g that can be reached directly from n.
|
||||
func (g *UndirectedMatrix) From(id int64) graph.Nodes {
|
||||
if !g.has(id) {
|
||||
return graph.Empty
|
||||
}
|
||||
var nodes []graph.Node
|
||||
r := g.mat.Symmetric()
|
||||
for i := 0; i < r; i++ {
|
||||
if int64(i) == id {
|
||||
continue
|
||||
}
|
||||
// id is not greater than maximum int by this point.
|
||||
if !isSame(g.mat.At(int(id), i), g.absent) {
|
||||
nodes = append(nodes, g.Node(int64(i)))
|
||||
}
|
||||
}
|
||||
if len(nodes) == 0 {
|
||||
return graph.Empty
|
||||
}
|
||||
return iterator.NewOrderedNodes(nodes)
|
||||
}
|
||||
|
||||
// HasEdgeBetween returns whether an edge exists between nodes x and y.
|
||||
func (g *UndirectedMatrix) HasEdgeBetween(uid, vid int64) bool {
|
||||
if !g.has(uid) {
|
||||
return false
|
||||
}
|
||||
if !g.has(vid) {
|
||||
return false
|
||||
}
|
||||
// uid and vid are not greater than maximum int by this point.
|
||||
return uid != vid && !isSame(g.mat.At(int(uid), int(vid)), g.absent)
|
||||
}
|
||||
|
||||
// Matrix returns the mat.Matrix representation of the graph.
|
||||
func (g *UndirectedMatrix) Matrix() mat.Matrix {
|
||||
// Prevent alteration of dimensions of the returned matrix.
|
||||
m := *g.mat
|
||||
return &m
|
||||
}
|
||||
|
||||
// Node returns the node with the given ID if it exists in the graph,
|
||||
// and nil otherwise.
|
||||
func (g *UndirectedMatrix) Node(id int64) graph.Node {
|
||||
if !g.has(id) {
|
||||
return nil
|
||||
}
|
||||
if g.nodes == nil {
|
||||
return Node(id)
|
||||
}
|
||||
return g.nodes[id]
|
||||
}
|
||||
|
||||
// Nodes returns all the nodes in the graph.
|
||||
func (g *UndirectedMatrix) Nodes() graph.Nodes {
|
||||
if g.nodes != nil {
|
||||
nodes := make([]graph.Node, len(g.nodes))
|
||||
copy(nodes, g.nodes)
|
||||
return iterator.NewOrderedNodes(nodes)
|
||||
}
|
||||
r := g.mat.Symmetric()
|
||||
// Matrix graphs must have at least one node.
|
||||
return iterator.NewImplicitNodes(0, r, newSimpleNode)
|
||||
}
|
||||
|
||||
// RemoveEdge removes the edge with the given end point IDs from the graph, leaving the terminal
|
||||
// nodes. If the edge does not exist it is a no-op.
|
||||
func (g *UndirectedMatrix) RemoveEdge(fid, tid int64) {
|
||||
if !g.has(fid) {
|
||||
return
|
||||
}
|
||||
if !g.has(tid) {
|
||||
return
|
||||
}
|
||||
// fid and tid are not greater than maximum int by this point.
|
||||
g.mat.SetSym(int(fid), int(tid), g.absent)
|
||||
}
|
||||
|
||||
// SetEdge sets e, an edge from one node to another with unit weight. If the ends of the edge are
|
||||
// not in g or the edge is a self loop, SetEdge panics. SetEdge will store the nodes of
|
||||
// e in the graph if it was initialized with NewUndirectedMatrixFrom.
|
||||
func (g *UndirectedMatrix) SetEdge(e graph.Edge) {
|
||||
g.setWeightedEdge(e, 1)
|
||||
}
|
||||
|
||||
// SetWeightedEdge sets e, an edge from one node to another. If the ends of the edge are not in g
|
||||
// or the edge is a self loop, SetWeightedEdge panics. SetWeightedEdge will store the nodes of
|
||||
// e in the graph if it was initialized with NewUndirectedMatrixFrom.
|
||||
func (g *UndirectedMatrix) SetWeightedEdge(e graph.WeightedEdge) {
|
||||
g.setWeightedEdge(e, e.Weight())
|
||||
}
|
||||
|
||||
func (g *UndirectedMatrix) setWeightedEdge(e graph.Edge, weight float64) {
|
||||
from := e.From()
|
||||
fid := from.ID()
|
||||
to := e.To()
|
||||
tid := to.ID()
|
||||
if fid == tid {
|
||||
panic("simple: set illegal edge")
|
||||
}
|
||||
if int64(int(fid)) != fid {
|
||||
panic("simple: unavailable from node ID for dense graph")
|
||||
}
|
||||
if int64(int(tid)) != tid {
|
||||
panic("simple: unavailable to node ID for dense graph")
|
||||
}
|
||||
if g.nodes != nil {
|
||||
g.nodes[fid] = from
|
||||
g.nodes[tid] = to
|
||||
}
|
||||
// fid and tid are not greater than maximum int by this point.
|
||||
g.mat.SetSym(int(fid), int(tid), weight)
|
||||
}
|
||||
|
||||
// Weight returns the weight for the edge between x and y if Edge(x, y) returns a non-nil Edge.
|
||||
// If x and y are the same node or there is no joining edge between the two nodes the weight
|
||||
// value returned is either the graph's absent or self value. Weight returns true if an edge
|
||||
// exists between x and y or if x and y have the same ID, false otherwise.
|
||||
func (g *UndirectedMatrix) Weight(xid, yid int64) (w float64, ok bool) {
|
||||
if xid == yid {
|
||||
return g.self, true
|
||||
}
|
||||
if g.HasEdgeBetween(xid, yid) {
|
||||
// xid and yid are not greater than maximum int by this point.
|
||||
return g.mat.At(int(xid), int(yid)), true
|
||||
}
|
||||
return g.absent, false
|
||||
}
|
||||
|
||||
// WeightedEdge returns the weighted edge from u to v if such an edge exists and nil otherwise.
|
||||
// The node v must be directly reachable from u as defined by the From method.
|
||||
func (g *UndirectedMatrix) WeightedEdge(uid, vid int64) graph.WeightedEdge {
|
||||
return g.WeightedEdgeBetween(uid, vid)
|
||||
}
|
||||
|
||||
// WeightedEdgeBetween returns the weighted edge between nodes x and y.
|
||||
func (g *UndirectedMatrix) WeightedEdgeBetween(uid, vid int64) graph.WeightedEdge {
|
||||
if g.HasEdgeBetween(uid, vid) {
|
||||
// uid and vid are not greater than maximum int by this point.
|
||||
return WeightedEdge{F: g.Node(uid), T: g.Node(vid), W: g.mat.At(int(uid), int(vid))}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// WeightedEdges returns all the edges in the graph.
|
||||
func (g *UndirectedMatrix) WeightedEdges() graph.WeightedEdges {
|
||||
var edges []graph.WeightedEdge
|
||||
r, _ := g.mat.Dims()
|
||||
for i := 0; i < r; i++ {
|
||||
for j := i + 1; j < r; j++ {
|
||||
if w := g.mat.At(i, j); !isSame(w, g.absent) {
|
||||
edges = append(edges, WeightedEdge{F: g.Node(int64(i)), T: g.Node(int64(j)), W: w})
|
||||
}
|
||||
}
|
||||
}
|
||||
if len(edges) == 0 {
|
||||
return graph.Empty
|
||||
}
|
||||
return iterator.NewOrderedWeightedEdges(edges)
|
||||
}
|
||||
|
||||
func (g *UndirectedMatrix) has(id int64) bool {
|
||||
r := g.mat.Symmetric()
|
||||
return 0 <= id && id < int64(r)
|
||||
}
|
||||
235
vendor/gonum.org/v1/gonum/graph/simple/directed.go
generated
vendored
Normal file
235
vendor/gonum.org/v1/gonum/graph/simple/directed.go
generated
vendored
Normal file
@@ -0,0 +1,235 @@
|
||||
// Copyright ©2014 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package simple
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"gonum.org/v1/gonum/graph"
|
||||
"gonum.org/v1/gonum/graph/internal/uid"
|
||||
"gonum.org/v1/gonum/graph/iterator"
|
||||
)
|
||||
|
||||
var (
|
||||
dg *DirectedGraph
|
||||
|
||||
_ graph.Graph = dg
|
||||
_ graph.Directed = dg
|
||||
_ graph.NodeAdder = dg
|
||||
_ graph.NodeRemover = dg
|
||||
_ graph.EdgeAdder = dg
|
||||
_ graph.EdgeRemover = dg
|
||||
)
|
||||
|
||||
// DirectedGraph implements a generalized directed graph.
|
||||
type DirectedGraph struct {
|
||||
nodes map[int64]graph.Node
|
||||
from map[int64]map[int64]graph.Edge
|
||||
to map[int64]map[int64]graph.Edge
|
||||
|
||||
nodeIDs uid.Set
|
||||
}
|
||||
|
||||
// NewDirectedGraph returns a DirectedGraph.
|
||||
func NewDirectedGraph() *DirectedGraph {
|
||||
return &DirectedGraph{
|
||||
nodes: make(map[int64]graph.Node),
|
||||
from: make(map[int64]map[int64]graph.Edge),
|
||||
to: make(map[int64]map[int64]graph.Edge),
|
||||
|
||||
nodeIDs: uid.NewSet(),
|
||||
}
|
||||
}
|
||||
|
||||
// AddNode adds n to the graph. It panics if the added node ID matches an existing node ID.
|
||||
func (g *DirectedGraph) AddNode(n graph.Node) {
|
||||
if _, exists := g.nodes[n.ID()]; exists {
|
||||
panic(fmt.Sprintf("simple: node ID collision: %d", n.ID()))
|
||||
}
|
||||
g.nodes[n.ID()] = n
|
||||
g.from[n.ID()] = make(map[int64]graph.Edge)
|
||||
g.to[n.ID()] = make(map[int64]graph.Edge)
|
||||
g.nodeIDs.Use(n.ID())
|
||||
}
|
||||
|
||||
// Edge returns the edge from u to v if such an edge exists and nil otherwise.
|
||||
// The node v must be directly reachable from u as defined by the From method.
|
||||
func (g *DirectedGraph) Edge(uid, vid int64) graph.Edge {
|
||||
edge, ok := g.from[uid][vid]
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
return edge
|
||||
}
|
||||
|
||||
// Edges returns all the edges in the graph.
|
||||
func (g *DirectedGraph) Edges() graph.Edges {
|
||||
var edges []graph.Edge
|
||||
for _, u := range g.nodes {
|
||||
for _, e := range g.from[u.ID()] {
|
||||
edges = append(edges, e)
|
||||
}
|
||||
}
|
||||
if len(edges) == 0 {
|
||||
return graph.Empty
|
||||
}
|
||||
return iterator.NewOrderedEdges(edges)
|
||||
}
|
||||
|
||||
// From returns all nodes in g that can be reached directly from n.
|
||||
func (g *DirectedGraph) From(id int64) graph.Nodes {
|
||||
if _, ok := g.from[id]; !ok {
|
||||
return graph.Empty
|
||||
}
|
||||
|
||||
from := make([]graph.Node, len(g.from[id]))
|
||||
i := 0
|
||||
for vid := range g.from[id] {
|
||||
from[i] = g.nodes[vid]
|
||||
i++
|
||||
}
|
||||
if len(from) == 0 {
|
||||
return graph.Empty
|
||||
}
|
||||
return iterator.NewOrderedNodes(from)
|
||||
}
|
||||
|
||||
// HasEdgeBetween returns whether an edge exists between nodes x and y without
|
||||
// considering direction.
|
||||
func (g *DirectedGraph) HasEdgeBetween(xid, yid int64) bool {
|
||||
if _, ok := g.from[xid][yid]; ok {
|
||||
return true
|
||||
}
|
||||
_, ok := g.from[yid][xid]
|
||||
return ok
|
||||
}
|
||||
|
||||
// HasEdgeFromTo returns whether an edge exists in the graph from u to v.
|
||||
func (g *DirectedGraph) HasEdgeFromTo(uid, vid int64) bool {
|
||||
if _, ok := g.from[uid][vid]; !ok {
|
||||
return false
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// NewEdge returns a new Edge from the source to the destination node.
|
||||
func (g *DirectedGraph) NewEdge(from, to graph.Node) graph.Edge {
|
||||
return &Edge{F: from, T: to}
|
||||
}
|
||||
|
||||
// NewNode returns a new unique Node to be added to g. The Node's ID does
|
||||
// not become valid in g until the Node is added to g.
|
||||
func (g *DirectedGraph) NewNode() graph.Node {
|
||||
if len(g.nodes) == 0 {
|
||||
return Node(0)
|
||||
}
|
||||
if int64(len(g.nodes)) == uid.Max {
|
||||
panic("simple: cannot allocate node: no slot")
|
||||
}
|
||||
return Node(g.nodeIDs.NewID())
|
||||
}
|
||||
|
||||
// Node returns the node with the given ID if it exists in the graph,
|
||||
// and nil otherwise.
|
||||
func (g *DirectedGraph) Node(id int64) graph.Node {
|
||||
return g.nodes[id]
|
||||
}
|
||||
|
||||
// Nodes returns all the nodes in the graph.
|
||||
func (g *DirectedGraph) Nodes() graph.Nodes {
|
||||
if len(g.nodes) == 0 {
|
||||
return graph.Empty
|
||||
}
|
||||
nodes := make([]graph.Node, len(g.nodes))
|
||||
i := 0
|
||||
for _, n := range g.nodes {
|
||||
nodes[i] = n
|
||||
i++
|
||||
}
|
||||
return iterator.NewOrderedNodes(nodes)
|
||||
}
|
||||
|
||||
// RemoveEdge removes the edge with the given end point IDs from the graph, leaving the terminal
|
||||
// nodes. If the edge does not exist it is a no-op.
|
||||
func (g *DirectedGraph) RemoveEdge(fid, tid int64) {
|
||||
if _, ok := g.nodes[fid]; !ok {
|
||||
return
|
||||
}
|
||||
if _, ok := g.nodes[tid]; !ok {
|
||||
return
|
||||
}
|
||||
|
||||
delete(g.from[fid], tid)
|
||||
delete(g.to[tid], fid)
|
||||
}
|
||||
|
||||
// RemoveNode removes the node with the given ID from the graph, as well as any edges attached
|
||||
// to it. If the node is not in the graph it is a no-op.
|
||||
func (g *DirectedGraph) RemoveNode(id int64) {
|
||||
if _, ok := g.nodes[id]; !ok {
|
||||
return
|
||||
}
|
||||
delete(g.nodes, id)
|
||||
|
||||
for from := range g.from[id] {
|
||||
delete(g.to[from], id)
|
||||
}
|
||||
delete(g.from, id)
|
||||
|
||||
for to := range g.to[id] {
|
||||
delete(g.from[to], id)
|
||||
}
|
||||
delete(g.to, id)
|
||||
|
||||
g.nodeIDs.Release(id)
|
||||
}
|
||||
|
||||
// SetEdge adds e, an edge from one node to another. If the nodes do not exist, they are added
|
||||
// and are set to the nodes of the edge otherwise.
|
||||
// It will panic if the IDs of the e.From and e.To are equal.
|
||||
func (g *DirectedGraph) SetEdge(e graph.Edge) {
|
||||
var (
|
||||
from = e.From()
|
||||
fid = from.ID()
|
||||
to = e.To()
|
||||
tid = to.ID()
|
||||
)
|
||||
|
||||
if fid == tid {
|
||||
panic("simple: adding self edge")
|
||||
}
|
||||
|
||||
if _, ok := g.nodes[fid]; !ok {
|
||||
g.AddNode(from)
|
||||
} else {
|
||||
g.nodes[fid] = from
|
||||
}
|
||||
if _, ok := g.nodes[tid]; !ok {
|
||||
g.AddNode(to)
|
||||
} else {
|
||||
g.nodes[tid] = to
|
||||
}
|
||||
|
||||
g.from[fid][tid] = e
|
||||
g.to[tid][fid] = e
|
||||
}
|
||||
|
||||
// To returns all nodes in g that can reach directly to n.
|
||||
func (g *DirectedGraph) To(id int64) graph.Nodes {
|
||||
if _, ok := g.from[id]; !ok {
|
||||
return graph.Empty
|
||||
}
|
||||
|
||||
to := make([]graph.Node, len(g.to[id]))
|
||||
i := 0
|
||||
for uid := range g.to[id] {
|
||||
to[i] = g.nodes[uid]
|
||||
i++
|
||||
}
|
||||
if len(to) == 0 {
|
||||
return graph.Empty
|
||||
}
|
||||
return iterator.NewOrderedNodes(to)
|
||||
}
|
||||
9
vendor/gonum.org/v1/gonum/graph/simple/doc.go
generated
vendored
Normal file
9
vendor/gonum.org/v1/gonum/graph/simple/doc.go
generated
vendored
Normal file
@@ -0,0 +1,9 @@
|
||||
// Copyright ©2017 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
// Package simple provides a suite of simple graph implementations satisfying
|
||||
// the gonum/graph interfaces.
|
||||
//
|
||||
// All types in simple return the graph.Empty value for empty iterators.
|
||||
package simple // import "gonum.org/v1/gonum/graph/simple"
|
||||
72
vendor/gonum.org/v1/gonum/graph/simple/simple.go
generated
vendored
Normal file
72
vendor/gonum.org/v1/gonum/graph/simple/simple.go
generated
vendored
Normal file
@@ -0,0 +1,72 @@
|
||||
// Copyright ©2014 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package simple
|
||||
|
||||
import (
|
||||
"math"
|
||||
|
||||
"gonum.org/v1/gonum/graph"
|
||||
)
|
||||
|
||||
// Node is a simple graph node.
|
||||
type Node int64
|
||||
|
||||
// ID returns the ID number of the node.
|
||||
func (n Node) ID() int64 {
|
||||
return int64(n)
|
||||
}
|
||||
|
||||
func newSimpleNode(id int) graph.Node {
|
||||
return Node(id)
|
||||
}
|
||||
|
||||
// Edge is a simple graph edge.
|
||||
type Edge struct {
|
||||
F, T graph.Node
|
||||
}
|
||||
|
||||
// From returns the from-node of the edge.
|
||||
func (e Edge) From() graph.Node { return e.F }
|
||||
|
||||
// To returns the to-node of the edge.
|
||||
func (e Edge) To() graph.Node { return e.T }
|
||||
|
||||
// ReversedLine returns a new Edge with the F and T fields
|
||||
// swapped.
|
||||
func (e Edge) ReversedEdge() graph.Edge { return Edge{F: e.T, T: e.F} }
|
||||
|
||||
// WeightedEdge is a simple weighted graph edge.
|
||||
type WeightedEdge struct {
|
||||
F, T graph.Node
|
||||
W float64
|
||||
}
|
||||
|
||||
// From returns the from-node of the edge.
|
||||
func (e WeightedEdge) From() graph.Node { return e.F }
|
||||
|
||||
// To returns the to-node of the edge.
|
||||
func (e WeightedEdge) To() graph.Node { return e.T }
|
||||
|
||||
// ReversedLine returns a new Edge with the F and T fields
|
||||
// swapped. The weight of the new Edge is the same as
|
||||
// the weight of the receiver.
|
||||
func (e WeightedEdge) ReversedEdge() graph.Edge { return WeightedEdge{F: e.T, T: e.F, W: e.W} }
|
||||
|
||||
// Weight returns the weight of the edge.
|
||||
func (e WeightedEdge) Weight() float64 { return e.W }
|
||||
|
||||
// isSame returns whether two float64 values are the same where NaN values
|
||||
// are equalable.
|
||||
func isSame(a, b float64) bool {
|
||||
return a == b || (math.IsNaN(a) && math.IsNaN(b))
|
||||
}
|
||||
|
||||
type edgeSetter interface {
|
||||
SetEdge(e graph.Edge)
|
||||
}
|
||||
|
||||
type weightedEdgeSetter interface {
|
||||
SetWeightedEdge(e graph.WeightedEdge)
|
||||
}
|
||||
216
vendor/gonum.org/v1/gonum/graph/simple/undirected.go
generated
vendored
Normal file
216
vendor/gonum.org/v1/gonum/graph/simple/undirected.go
generated
vendored
Normal file
@@ -0,0 +1,216 @@
|
||||
// Copyright ©2014 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package simple
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"gonum.org/v1/gonum/graph"
|
||||
"gonum.org/v1/gonum/graph/internal/uid"
|
||||
"gonum.org/v1/gonum/graph/iterator"
|
||||
)
|
||||
|
||||
var (
|
||||
ug *UndirectedGraph
|
||||
|
||||
_ graph.Graph = ug
|
||||
_ graph.Undirected = ug
|
||||
_ graph.NodeAdder = ug
|
||||
_ graph.NodeRemover = ug
|
||||
_ graph.EdgeAdder = ug
|
||||
_ graph.EdgeRemover = ug
|
||||
)
|
||||
|
||||
// UndirectedGraph implements a generalized undirected graph.
|
||||
type UndirectedGraph struct {
|
||||
nodes map[int64]graph.Node
|
||||
edges map[int64]map[int64]graph.Edge
|
||||
|
||||
nodeIDs uid.Set
|
||||
}
|
||||
|
||||
// NewUndirectedGraph returns an UndirectedGraph.
|
||||
func NewUndirectedGraph() *UndirectedGraph {
|
||||
return &UndirectedGraph{
|
||||
nodes: make(map[int64]graph.Node),
|
||||
edges: make(map[int64]map[int64]graph.Edge),
|
||||
|
||||
nodeIDs: uid.NewSet(),
|
||||
}
|
||||
}
|
||||
|
||||
// AddNode adds n to the graph. It panics if the added node ID matches an existing node ID.
|
||||
func (g *UndirectedGraph) AddNode(n graph.Node) {
|
||||
if _, exists := g.nodes[n.ID()]; exists {
|
||||
panic(fmt.Sprintf("simple: node ID collision: %d", n.ID()))
|
||||
}
|
||||
g.nodes[n.ID()] = n
|
||||
g.edges[n.ID()] = make(map[int64]graph.Edge)
|
||||
g.nodeIDs.Use(n.ID())
|
||||
}
|
||||
|
||||
// Edge returns the edge from u to v if such an edge exists and nil otherwise.
|
||||
// The node v must be directly reachable from u as defined by the From method.
|
||||
func (g *UndirectedGraph) Edge(uid, vid int64) graph.Edge {
|
||||
return g.EdgeBetween(uid, vid)
|
||||
}
|
||||
|
||||
// EdgeBetween returns the edge between nodes x and y.
|
||||
func (g *UndirectedGraph) EdgeBetween(xid, yid int64) graph.Edge {
|
||||
edge, ok := g.edges[xid][yid]
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
if edge.From().ID() == xid {
|
||||
return edge
|
||||
}
|
||||
return edge.ReversedEdge()
|
||||
}
|
||||
|
||||
// Edges returns all the edges in the graph.
|
||||
func (g *UndirectedGraph) Edges() graph.Edges {
|
||||
if len(g.edges) == 0 {
|
||||
return graph.Empty
|
||||
}
|
||||
var edges []graph.Edge
|
||||
seen := make(map[[2]int64]struct{})
|
||||
for _, u := range g.edges {
|
||||
for _, e := range u {
|
||||
uid := e.From().ID()
|
||||
vid := e.To().ID()
|
||||
if _, ok := seen[[2]int64{uid, vid}]; ok {
|
||||
continue
|
||||
}
|
||||
seen[[2]int64{uid, vid}] = struct{}{}
|
||||
seen[[2]int64{vid, uid}] = struct{}{}
|
||||
edges = append(edges, e)
|
||||
}
|
||||
}
|
||||
if len(edges) == 0 {
|
||||
return graph.Empty
|
||||
}
|
||||
return iterator.NewOrderedEdges(edges)
|
||||
}
|
||||
|
||||
// From returns all nodes in g that can be reached directly from n.
|
||||
func (g *UndirectedGraph) From(id int64) graph.Nodes {
|
||||
if _, ok := g.nodes[id]; !ok {
|
||||
return graph.Empty
|
||||
}
|
||||
|
||||
nodes := make([]graph.Node, len(g.edges[id]))
|
||||
i := 0
|
||||
for from := range g.edges[id] {
|
||||
nodes[i] = g.nodes[from]
|
||||
i++
|
||||
}
|
||||
if len(nodes) == 0 {
|
||||
return graph.Empty
|
||||
}
|
||||
return iterator.NewOrderedNodes(nodes)
|
||||
}
|
||||
|
||||
// HasEdgeBetween returns whether an edge exists between nodes x and y.
|
||||
func (g *UndirectedGraph) HasEdgeBetween(xid, yid int64) bool {
|
||||
_, ok := g.edges[xid][yid]
|
||||
return ok
|
||||
}
|
||||
|
||||
// NewEdge returns a new Edge from the source to the destination node.
|
||||
func (g *UndirectedGraph) NewEdge(from, to graph.Node) graph.Edge {
|
||||
return &Edge{F: from, T: to}
|
||||
}
|
||||
|
||||
// NewNode returns a new unique Node to be added to g. The Node's ID does
|
||||
// not become valid in g until the Node is added to g.
|
||||
func (g *UndirectedGraph) NewNode() graph.Node {
|
||||
if len(g.nodes) == 0 {
|
||||
return Node(0)
|
||||
}
|
||||
if int64(len(g.nodes)) == uid.Max {
|
||||
panic("simple: cannot allocate node: no slot")
|
||||
}
|
||||
return Node(g.nodeIDs.NewID())
|
||||
}
|
||||
|
||||
// Node returns the node with the given ID if it exists in the graph,
|
||||
// and nil otherwise.
|
||||
func (g *UndirectedGraph) Node(id int64) graph.Node {
|
||||
return g.nodes[id]
|
||||
}
|
||||
|
||||
// Nodes returns all the nodes in the graph.
|
||||
func (g *UndirectedGraph) Nodes() graph.Nodes {
|
||||
if len(g.nodes) == 0 {
|
||||
return graph.Empty
|
||||
}
|
||||
nodes := make([]graph.Node, len(g.nodes))
|
||||
i := 0
|
||||
for _, n := range g.nodes {
|
||||
nodes[i] = n
|
||||
i++
|
||||
}
|
||||
return iterator.NewOrderedNodes(nodes)
|
||||
}
|
||||
|
||||
// RemoveEdge removes the edge with the given end IDs from the graph, leaving the terminal nodes.
|
||||
// If the edge does not exist it is a no-op.
|
||||
func (g *UndirectedGraph) RemoveEdge(fid, tid int64) {
|
||||
if _, ok := g.nodes[fid]; !ok {
|
||||
return
|
||||
}
|
||||
if _, ok := g.nodes[tid]; !ok {
|
||||
return
|
||||
}
|
||||
|
||||
delete(g.edges[fid], tid)
|
||||
delete(g.edges[tid], fid)
|
||||
}
|
||||
|
||||
// RemoveNode removes the node with the given ID from the graph, as well as any edges attached
|
||||
// to it. If the node is not in the graph it is a no-op.
|
||||
func (g *UndirectedGraph) RemoveNode(id int64) {
|
||||
if _, ok := g.nodes[id]; !ok {
|
||||
return
|
||||
}
|
||||
delete(g.nodes, id)
|
||||
|
||||
for from := range g.edges[id] {
|
||||
delete(g.edges[from], id)
|
||||
}
|
||||
delete(g.edges, id)
|
||||
|
||||
g.nodeIDs.Release(id)
|
||||
}
|
||||
|
||||
// SetEdge adds e, an edge from one node to another. If the nodes do not exist, they are added
|
||||
// and are set to the nodes of the edge otherwise.
|
||||
// It will panic if the IDs of the e.From and e.To are equal.
|
||||
func (g *UndirectedGraph) SetEdge(e graph.Edge) {
|
||||
var (
|
||||
from = e.From()
|
||||
fid = from.ID()
|
||||
to = e.To()
|
||||
tid = to.ID()
|
||||
)
|
||||
|
||||
if fid == tid {
|
||||
panic("simple: adding self edge")
|
||||
}
|
||||
|
||||
if _, ok := g.nodes[fid]; !ok {
|
||||
g.AddNode(from)
|
||||
} else {
|
||||
g.nodes[fid] = from
|
||||
}
|
||||
if _, ok := g.nodes[tid]; !ok {
|
||||
g.AddNode(to)
|
||||
} else {
|
||||
g.nodes[tid] = to
|
||||
}
|
||||
|
||||
g.edges[fid][tid] = e
|
||||
g.edges[tid][fid] = e
|
||||
}
|
||||
279
vendor/gonum.org/v1/gonum/graph/simple/weighted_directed.go
generated
vendored
Normal file
279
vendor/gonum.org/v1/gonum/graph/simple/weighted_directed.go
generated
vendored
Normal file
@@ -0,0 +1,279 @@
|
||||
// Copyright ©2014 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package simple
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"gonum.org/v1/gonum/graph"
|
||||
"gonum.org/v1/gonum/graph/internal/uid"
|
||||
"gonum.org/v1/gonum/graph/iterator"
|
||||
)
|
||||
|
||||
var (
|
||||
wdg *WeightedDirectedGraph
|
||||
|
||||
_ graph.Graph = wdg
|
||||
_ graph.Weighted = wdg
|
||||
_ graph.Directed = wdg
|
||||
_ graph.WeightedDirected = wdg
|
||||
_ graph.NodeAdder = wdg
|
||||
_ graph.NodeRemover = wdg
|
||||
_ graph.WeightedEdgeAdder = wdg
|
||||
_ graph.EdgeRemover = wdg
|
||||
)
|
||||
|
||||
// WeightedDirectedGraph implements a generalized weighted directed graph.
|
||||
type WeightedDirectedGraph struct {
|
||||
nodes map[int64]graph.Node
|
||||
from map[int64]map[int64]graph.WeightedEdge
|
||||
to map[int64]map[int64]graph.WeightedEdge
|
||||
|
||||
self, absent float64
|
||||
|
||||
nodeIDs uid.Set
|
||||
}
|
||||
|
||||
// NewWeightedDirectedGraph returns a WeightedDirectedGraph with the specified self and absent
|
||||
// edge weight values.
|
||||
func NewWeightedDirectedGraph(self, absent float64) *WeightedDirectedGraph {
|
||||
return &WeightedDirectedGraph{
|
||||
nodes: make(map[int64]graph.Node),
|
||||
from: make(map[int64]map[int64]graph.WeightedEdge),
|
||||
to: make(map[int64]map[int64]graph.WeightedEdge),
|
||||
|
||||
self: self,
|
||||
absent: absent,
|
||||
|
||||
nodeIDs: uid.NewSet(),
|
||||
}
|
||||
}
|
||||
|
||||
// AddNode adds n to the graph. It panics if the added node ID matches an existing node ID.
|
||||
func (g *WeightedDirectedGraph) AddNode(n graph.Node) {
|
||||
if _, exists := g.nodes[n.ID()]; exists {
|
||||
panic(fmt.Sprintf("simple: node ID collision: %d", n.ID()))
|
||||
}
|
||||
g.nodes[n.ID()] = n
|
||||
g.from[n.ID()] = make(map[int64]graph.WeightedEdge)
|
||||
g.to[n.ID()] = make(map[int64]graph.WeightedEdge)
|
||||
g.nodeIDs.Use(n.ID())
|
||||
}
|
||||
|
||||
// Edge returns the edge from u to v if such an edge exists and nil otherwise.
|
||||
// The node v must be directly reachable from u as defined by the From method.
|
||||
func (g *WeightedDirectedGraph) Edge(uid, vid int64) graph.Edge {
|
||||
return g.WeightedEdge(uid, vid)
|
||||
}
|
||||
|
||||
// Edges returns all the edges in the graph.
|
||||
func (g *WeightedDirectedGraph) Edges() graph.Edges {
|
||||
var edges []graph.Edge
|
||||
for _, u := range g.nodes {
|
||||
for _, e := range g.from[u.ID()] {
|
||||
edges = append(edges, e)
|
||||
}
|
||||
}
|
||||
if len(edges) == 0 {
|
||||
return graph.Empty
|
||||
}
|
||||
return iterator.NewOrderedEdges(edges)
|
||||
}
|
||||
|
||||
// From returns all nodes in g that can be reached directly from n.
|
||||
func (g *WeightedDirectedGraph) From(id int64) graph.Nodes {
|
||||
if _, ok := g.from[id]; !ok {
|
||||
return graph.Empty
|
||||
}
|
||||
|
||||
from := make([]graph.Node, len(g.from[id]))
|
||||
i := 0
|
||||
for vid := range g.from[id] {
|
||||
from[i] = g.nodes[vid]
|
||||
i++
|
||||
}
|
||||
if len(from) == 0 {
|
||||
return graph.Empty
|
||||
}
|
||||
return iterator.NewOrderedNodes(from)
|
||||
}
|
||||
|
||||
// HasEdgeBetween returns whether an edge exists between nodes x and y without
|
||||
// considering direction.
|
||||
func (g *WeightedDirectedGraph) HasEdgeBetween(xid, yid int64) bool {
|
||||
if _, ok := g.from[xid][yid]; ok {
|
||||
return true
|
||||
}
|
||||
_, ok := g.from[yid][xid]
|
||||
return ok
|
||||
}
|
||||
|
||||
// HasEdgeFromTo returns whether an edge exists in the graph from u to v.
|
||||
func (g *WeightedDirectedGraph) HasEdgeFromTo(uid, vid int64) bool {
|
||||
if _, ok := g.from[uid][vid]; !ok {
|
||||
return false
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// NewNode returns a new unique Node to be added to g. The Node's ID does
|
||||
// not become valid in g until the Node is added to g.
|
||||
func (g *WeightedDirectedGraph) NewNode() graph.Node {
|
||||
if len(g.nodes) == 0 {
|
||||
return Node(0)
|
||||
}
|
||||
if int64(len(g.nodes)) == uid.Max {
|
||||
panic("simple: cannot allocate node: no slot")
|
||||
}
|
||||
return Node(g.nodeIDs.NewID())
|
||||
}
|
||||
|
||||
// NewWeightedEdge returns a new weighted edge from the source to the destination node.
|
||||
func (g *WeightedDirectedGraph) NewWeightedEdge(from, to graph.Node, weight float64) graph.WeightedEdge {
|
||||
return &WeightedEdge{F: from, T: to, W: weight}
|
||||
}
|
||||
|
||||
// Node returns the node with the given ID if it exists in the graph,
|
||||
// and nil otherwise.
|
||||
func (g *WeightedDirectedGraph) Node(id int64) graph.Node {
|
||||
return g.nodes[id]
|
||||
}
|
||||
|
||||
// Nodes returns all the nodes in the graph.
|
||||
func (g *WeightedDirectedGraph) Nodes() graph.Nodes {
|
||||
if len(g.from) == 0 {
|
||||
return graph.Empty
|
||||
}
|
||||
nodes := make([]graph.Node, len(g.nodes))
|
||||
i := 0
|
||||
for _, n := range g.nodes {
|
||||
nodes[i] = n
|
||||
i++
|
||||
}
|
||||
return iterator.NewOrderedNodes(nodes)
|
||||
}
|
||||
|
||||
// RemoveEdge removes the edge with the given end point IDs from the graph, leaving the terminal
|
||||
// nodes. If the edge does not exist it is a no-op.
|
||||
func (g *WeightedDirectedGraph) RemoveEdge(fid, tid int64) {
|
||||
if _, ok := g.nodes[fid]; !ok {
|
||||
return
|
||||
}
|
||||
if _, ok := g.nodes[tid]; !ok {
|
||||
return
|
||||
}
|
||||
|
||||
delete(g.from[fid], tid)
|
||||
delete(g.to[tid], fid)
|
||||
}
|
||||
|
||||
// RemoveNode removes the node with the given ID from the graph, as well as any edges attached
|
||||
// to it. If the node is not in the graph it is a no-op.
|
||||
func (g *WeightedDirectedGraph) RemoveNode(id int64) {
|
||||
if _, ok := g.nodes[id]; !ok {
|
||||
return
|
||||
}
|
||||
delete(g.nodes, id)
|
||||
|
||||
for from := range g.from[id] {
|
||||
delete(g.to[from], id)
|
||||
}
|
||||
delete(g.from, id)
|
||||
|
||||
for to := range g.to[id] {
|
||||
delete(g.from[to], id)
|
||||
}
|
||||
delete(g.to, id)
|
||||
|
||||
g.nodeIDs.Release(id)
|
||||
}
|
||||
|
||||
// SetWeightedEdge adds a weighted edge from one node to another. If the nodes do not exist, they are added
|
||||
// and are set to the nodes of the edge otherwise.
|
||||
// It will panic if the IDs of the e.From and e.To are equal.
|
||||
func (g *WeightedDirectedGraph) SetWeightedEdge(e graph.WeightedEdge) {
|
||||
var (
|
||||
from = e.From()
|
||||
fid = from.ID()
|
||||
to = e.To()
|
||||
tid = to.ID()
|
||||
)
|
||||
|
||||
if fid == tid {
|
||||
panic("simple: adding self edge")
|
||||
}
|
||||
|
||||
if _, ok := g.nodes[fid]; !ok {
|
||||
g.AddNode(from)
|
||||
} else {
|
||||
g.nodes[fid] = from
|
||||
}
|
||||
if _, ok := g.nodes[tid]; !ok {
|
||||
g.AddNode(to)
|
||||
} else {
|
||||
g.nodes[tid] = to
|
||||
}
|
||||
|
||||
g.from[fid][tid] = e
|
||||
g.to[tid][fid] = e
|
||||
}
|
||||
|
||||
// To returns all nodes in g that can reach directly to n.
|
||||
func (g *WeightedDirectedGraph) To(id int64) graph.Nodes {
|
||||
if _, ok := g.from[id]; !ok {
|
||||
return graph.Empty
|
||||
}
|
||||
|
||||
to := make([]graph.Node, len(g.to[id]))
|
||||
i := 0
|
||||
for uid := range g.to[id] {
|
||||
to[i] = g.nodes[uid]
|
||||
i++
|
||||
}
|
||||
if len(to) == 0 {
|
||||
return graph.Empty
|
||||
}
|
||||
return iterator.NewOrderedNodes(to)
|
||||
}
|
||||
|
||||
// Weight returns the weight for the edge between x and y if Edge(x, y) returns a non-nil Edge.
|
||||
// If x and y are the same node or there is no joining edge between the two nodes the weight
|
||||
// value returned is either the graph's absent or self value. Weight returns true if an edge
|
||||
// exists between x and y or if x and y have the same ID, false otherwise.
|
||||
func (g *WeightedDirectedGraph) Weight(xid, yid int64) (w float64, ok bool) {
|
||||
if xid == yid {
|
||||
return g.self, true
|
||||
}
|
||||
if to, ok := g.from[xid]; ok {
|
||||
if e, ok := to[yid]; ok {
|
||||
return e.Weight(), true
|
||||
}
|
||||
}
|
||||
return g.absent, false
|
||||
}
|
||||
|
||||
// WeightedEdge returns the weighted edge from u to v if such an edge exists and nil otherwise.
|
||||
// The node v must be directly reachable from u as defined by the From method.
|
||||
func (g *WeightedDirectedGraph) WeightedEdge(uid, vid int64) graph.WeightedEdge {
|
||||
edge, ok := g.from[uid][vid]
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
return edge
|
||||
}
|
||||
|
||||
// WeightedEdges returns all the weighted edges in the graph.
|
||||
func (g *WeightedDirectedGraph) WeightedEdges() graph.WeightedEdges {
|
||||
var edges []graph.WeightedEdge
|
||||
for _, u := range g.nodes {
|
||||
for _, e := range g.from[u.ID()] {
|
||||
edges = append(edges, e)
|
||||
}
|
||||
}
|
||||
if len(edges) == 0 {
|
||||
return graph.Empty
|
||||
}
|
||||
return iterator.NewOrderedWeightedEdges(edges)
|
||||
}
|
||||
273
vendor/gonum.org/v1/gonum/graph/simple/weighted_undirected.go
generated
vendored
Normal file
273
vendor/gonum.org/v1/gonum/graph/simple/weighted_undirected.go
generated
vendored
Normal file
@@ -0,0 +1,273 @@
|
||||
// Copyright ©2014 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package simple
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"gonum.org/v1/gonum/graph"
|
||||
"gonum.org/v1/gonum/graph/internal/uid"
|
||||
"gonum.org/v1/gonum/graph/iterator"
|
||||
)
|
||||
|
||||
var (
|
||||
wug *WeightedUndirectedGraph
|
||||
|
||||
_ graph.Graph = wug
|
||||
_ graph.Weighted = wug
|
||||
_ graph.Undirected = wug
|
||||
_ graph.WeightedUndirected = wug
|
||||
_ graph.NodeAdder = wug
|
||||
_ graph.NodeRemover = wug
|
||||
_ graph.WeightedEdgeAdder = wug
|
||||
_ graph.EdgeRemover = wug
|
||||
)
|
||||
|
||||
// WeightedUndirectedGraph implements a generalized weighted undirected graph.
|
||||
type WeightedUndirectedGraph struct {
|
||||
nodes map[int64]graph.Node
|
||||
edges map[int64]map[int64]graph.WeightedEdge
|
||||
|
||||
self, absent float64
|
||||
|
||||
nodeIDs uid.Set
|
||||
}
|
||||
|
||||
// NewWeightedUndirectedGraph returns an WeightedUndirectedGraph with the specified self and absent
|
||||
// edge weight values.
|
||||
func NewWeightedUndirectedGraph(self, absent float64) *WeightedUndirectedGraph {
|
||||
return &WeightedUndirectedGraph{
|
||||
nodes: make(map[int64]graph.Node),
|
||||
edges: make(map[int64]map[int64]graph.WeightedEdge),
|
||||
|
||||
self: self,
|
||||
absent: absent,
|
||||
|
||||
nodeIDs: uid.NewSet(),
|
||||
}
|
||||
}
|
||||
|
||||
// AddNode adds n to the graph. It panics if the added node ID matches an existing node ID.
|
||||
func (g *WeightedUndirectedGraph) AddNode(n graph.Node) {
|
||||
if _, exists := g.nodes[n.ID()]; exists {
|
||||
panic(fmt.Sprintf("simple: node ID collision: %d", n.ID()))
|
||||
}
|
||||
g.nodes[n.ID()] = n
|
||||
g.edges[n.ID()] = make(map[int64]graph.WeightedEdge)
|
||||
g.nodeIDs.Use(n.ID())
|
||||
}
|
||||
|
||||
// Edge returns the edge from u to v if such an edge exists and nil otherwise.
|
||||
// The node v must be directly reachable from u as defined by the From method.
|
||||
func (g *WeightedUndirectedGraph) Edge(uid, vid int64) graph.Edge {
|
||||
return g.WeightedEdgeBetween(uid, vid)
|
||||
}
|
||||
|
||||
// EdgeBetween returns the edge between nodes x and y.
|
||||
func (g *WeightedUndirectedGraph) EdgeBetween(xid, yid int64) graph.Edge {
|
||||
return g.WeightedEdgeBetween(xid, yid)
|
||||
}
|
||||
|
||||
// Edges returns all the edges in the graph.
|
||||
func (g *WeightedUndirectedGraph) Edges() graph.Edges {
|
||||
if len(g.edges) == 0 {
|
||||
return graph.Empty
|
||||
}
|
||||
var edges []graph.Edge
|
||||
seen := make(map[[2]int64]struct{})
|
||||
for _, u := range g.edges {
|
||||
for _, e := range u {
|
||||
uid := e.From().ID()
|
||||
vid := e.To().ID()
|
||||
if _, ok := seen[[2]int64{uid, vid}]; ok {
|
||||
continue
|
||||
}
|
||||
seen[[2]int64{uid, vid}] = struct{}{}
|
||||
seen[[2]int64{vid, uid}] = struct{}{}
|
||||
edges = append(edges, e)
|
||||
}
|
||||
}
|
||||
if len(edges) == 0 {
|
||||
return graph.Empty
|
||||
}
|
||||
return iterator.NewOrderedEdges(edges)
|
||||
}
|
||||
|
||||
// From returns all nodes in g that can be reached directly from n.
|
||||
func (g *WeightedUndirectedGraph) From(id int64) graph.Nodes {
|
||||
if _, ok := g.nodes[id]; !ok {
|
||||
return graph.Empty
|
||||
}
|
||||
|
||||
nodes := make([]graph.Node, len(g.edges[id]))
|
||||
i := 0
|
||||
for from := range g.edges[id] {
|
||||
nodes[i] = g.nodes[from]
|
||||
i++
|
||||
}
|
||||
if len(nodes) == 0 {
|
||||
return graph.Empty
|
||||
}
|
||||
return iterator.NewOrderedNodes(nodes)
|
||||
}
|
||||
|
||||
// HasEdgeBetween returns whether an edge exists between nodes x and y.
|
||||
func (g *WeightedUndirectedGraph) HasEdgeBetween(xid, yid int64) bool {
|
||||
_, ok := g.edges[xid][yid]
|
||||
return ok
|
||||
}
|
||||
|
||||
// NewNode returns a new unique Node to be added to g. The Node's ID does
|
||||
// not become valid in g until the Node is added to g.
|
||||
func (g *WeightedUndirectedGraph) NewNode() graph.Node {
|
||||
if len(g.nodes) == 0 {
|
||||
return Node(0)
|
||||
}
|
||||
if int64(len(g.nodes)) == uid.Max {
|
||||
panic("simple: cannot allocate node: no slot")
|
||||
}
|
||||
return Node(g.nodeIDs.NewID())
|
||||
}
|
||||
|
||||
// NewWeightedEdge returns a new weighted edge from the source to the destination node.
|
||||
func (g *WeightedUndirectedGraph) NewWeightedEdge(from, to graph.Node, weight float64) graph.WeightedEdge {
|
||||
return &WeightedEdge{F: from, T: to, W: weight}
|
||||
}
|
||||
|
||||
// Node returns the node with the given ID if it exists in the graph,
|
||||
// and nil otherwise.
|
||||
func (g *WeightedUndirectedGraph) Node(id int64) graph.Node {
|
||||
return g.nodes[id]
|
||||
}
|
||||
|
||||
// Nodes returns all the nodes in the graph.
|
||||
func (g *WeightedUndirectedGraph) Nodes() graph.Nodes {
|
||||
if len(g.nodes) == 0 {
|
||||
return graph.Empty
|
||||
}
|
||||
nodes := make([]graph.Node, len(g.nodes))
|
||||
i := 0
|
||||
for _, n := range g.nodes {
|
||||
nodes[i] = n
|
||||
i++
|
||||
}
|
||||
return iterator.NewOrderedNodes(nodes)
|
||||
}
|
||||
|
||||
// RemoveEdge removes the edge with the given end point IDs from the graph, leaving the terminal
|
||||
// nodes. If the edge does not exist it is a no-op.
|
||||
func (g *WeightedUndirectedGraph) RemoveEdge(fid, tid int64) {
|
||||
if _, ok := g.nodes[fid]; !ok {
|
||||
return
|
||||
}
|
||||
if _, ok := g.nodes[tid]; !ok {
|
||||
return
|
||||
}
|
||||
|
||||
delete(g.edges[fid], tid)
|
||||
delete(g.edges[tid], fid)
|
||||
}
|
||||
|
||||
// RemoveNode removes the node with the given ID from the graph, as well as any edges attached
|
||||
// to it. If the node is not in the graph it is a no-op.
|
||||
func (g *WeightedUndirectedGraph) RemoveNode(id int64) {
|
||||
if _, ok := g.nodes[id]; !ok {
|
||||
return
|
||||
}
|
||||
delete(g.nodes, id)
|
||||
|
||||
for from := range g.edges[id] {
|
||||
delete(g.edges[from], id)
|
||||
}
|
||||
delete(g.edges, id)
|
||||
|
||||
g.nodeIDs.Release(id)
|
||||
}
|
||||
|
||||
// SetWeightedEdge adds a weighted edge from one node to another. If the nodes do not exist, they are added
|
||||
// and are set to the nodes of the edge otherwise.
|
||||
// It will panic if the IDs of the e.From and e.To are equal.
|
||||
func (g *WeightedUndirectedGraph) SetWeightedEdge(e graph.WeightedEdge) {
|
||||
var (
|
||||
from = e.From()
|
||||
fid = from.ID()
|
||||
to = e.To()
|
||||
tid = to.ID()
|
||||
)
|
||||
|
||||
if fid == tid {
|
||||
panic("simple: adding self edge")
|
||||
}
|
||||
|
||||
if _, ok := g.nodes[fid]; !ok {
|
||||
g.AddNode(from)
|
||||
} else {
|
||||
g.nodes[fid] = from
|
||||
}
|
||||
if _, ok := g.nodes[tid]; !ok {
|
||||
g.AddNode(to)
|
||||
} else {
|
||||
g.nodes[tid] = to
|
||||
}
|
||||
|
||||
g.edges[fid][tid] = e
|
||||
g.edges[tid][fid] = e
|
||||
}
|
||||
|
||||
// Weight returns the weight for the edge between x and y if Edge(x, y) returns a non-nil Edge.
|
||||
// If x and y are the same node or there is no joining edge between the two nodes the weight
|
||||
// value returned is either the graph's absent or self value. Weight returns true if an edge
|
||||
// exists between x and y or if x and y have the same ID, false otherwise.
|
||||
func (g *WeightedUndirectedGraph) Weight(xid, yid int64) (w float64, ok bool) {
|
||||
if xid == yid {
|
||||
return g.self, true
|
||||
}
|
||||
if n, ok := g.edges[xid]; ok {
|
||||
if e, ok := n[yid]; ok {
|
||||
return e.Weight(), true
|
||||
}
|
||||
}
|
||||
return g.absent, false
|
||||
}
|
||||
|
||||
// WeightedEdge returns the weighted edge from u to v if such an edge exists and nil otherwise.
|
||||
// The node v must be directly reachable from u as defined by the From method.
|
||||
func (g *WeightedUndirectedGraph) WeightedEdge(uid, vid int64) graph.WeightedEdge {
|
||||
return g.WeightedEdgeBetween(uid, vid)
|
||||
}
|
||||
|
||||
// WeightedEdgeBetween returns the weighted edge between nodes x and y.
|
||||
func (g *WeightedUndirectedGraph) WeightedEdgeBetween(xid, yid int64) graph.WeightedEdge {
|
||||
edge, ok := g.edges[xid][yid]
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
if edge.From().ID() == xid {
|
||||
return edge
|
||||
}
|
||||
return edge.ReversedEdge().(graph.WeightedEdge)
|
||||
}
|
||||
|
||||
// WeightedEdges returns all the weighted edges in the graph.
|
||||
func (g *WeightedUndirectedGraph) WeightedEdges() graph.WeightedEdges {
|
||||
var edges []graph.WeightedEdge
|
||||
seen := make(map[[2]int64]struct{})
|
||||
for _, u := range g.edges {
|
||||
for _, e := range u {
|
||||
uid := e.From().ID()
|
||||
vid := e.To().ID()
|
||||
if _, ok := seen[[2]int64{uid, vid}]; ok {
|
||||
continue
|
||||
}
|
||||
seen[[2]int64{uid, vid}] = struct{}{}
|
||||
seen[[2]int64{vid, uid}] = struct{}{}
|
||||
edges = append(edges, e)
|
||||
}
|
||||
}
|
||||
if len(edges) == 0 {
|
||||
return graph.Empty
|
||||
}
|
||||
return iterator.NewOrderedWeightedEdges(edges)
|
||||
}
|
||||
250
vendor/gonum.org/v1/gonum/graph/topo/bron_kerbosch.go
generated
vendored
Normal file
250
vendor/gonum.org/v1/gonum/graph/topo/bron_kerbosch.go
generated
vendored
Normal file
@@ -0,0 +1,250 @@
|
||||
// Copyright ©2015 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package topo
|
||||
|
||||
import (
|
||||
"gonum.org/v1/gonum/graph"
|
||||
"gonum.org/v1/gonum/graph/internal/ordered"
|
||||
"gonum.org/v1/gonum/graph/internal/set"
|
||||
)
|
||||
|
||||
// DegeneracyOrdering returns the degeneracy ordering and the k-cores of
|
||||
// the undirected graph g.
|
||||
func DegeneracyOrdering(g graph.Undirected) (order []graph.Node, cores [][]graph.Node) {
|
||||
order, offsets := degeneracyOrdering(g)
|
||||
|
||||
ordered.Reverse(order)
|
||||
cores = make([][]graph.Node, len(offsets))
|
||||
offset := len(order)
|
||||
for i, n := range offsets {
|
||||
cores[i] = order[offset-n : offset]
|
||||
offset -= n
|
||||
}
|
||||
return order, cores
|
||||
}
|
||||
|
||||
// KCore returns the k-core of the undirected graph g with nodes in an
|
||||
// optimal ordering for the coloring number.
|
||||
func KCore(k int, g graph.Undirected) []graph.Node {
|
||||
order, offsets := degeneracyOrdering(g)
|
||||
|
||||
var offset int
|
||||
for _, n := range offsets[:k] {
|
||||
offset += n
|
||||
}
|
||||
core := make([]graph.Node, len(order)-offset)
|
||||
copy(core, order[offset:])
|
||||
return core
|
||||
}
|
||||
|
||||
// degeneracyOrdering is the common code for DegeneracyOrdering and KCore. It
|
||||
// returns l, the nodes of g in optimal ordering for coloring number and
|
||||
// s, a set of relative offsets into l for each k-core, where k is an index
|
||||
// into s.
|
||||
func degeneracyOrdering(g graph.Undirected) (l []graph.Node, s []int) {
|
||||
nodes := graph.NodesOf(g.Nodes())
|
||||
|
||||
// The algorithm used here is essentially as described at
|
||||
// http://en.wikipedia.org/w/index.php?title=Degeneracy_%28graph_theory%29&oldid=640308710
|
||||
|
||||
// Initialize an output list L in return parameters.
|
||||
|
||||
// Compute a number d_v for each vertex v in G,
|
||||
// the number of neighbors of v that are not already in L.
|
||||
// Initially, these numbers are just the degrees of the vertices.
|
||||
dv := make(map[int64]int, len(nodes))
|
||||
var (
|
||||
maxDegree int
|
||||
neighbours = make(map[int64][]graph.Node)
|
||||
)
|
||||
for _, n := range nodes {
|
||||
id := n.ID()
|
||||
adj := graph.NodesOf(g.From(id))
|
||||
neighbours[id] = adj
|
||||
dv[id] = len(adj)
|
||||
if len(adj) > maxDegree {
|
||||
maxDegree = len(adj)
|
||||
}
|
||||
}
|
||||
|
||||
// Initialize an array D such that D[i] contains a list of the
|
||||
// vertices v that are not already in L for which d_v = i.
|
||||
d := make([][]graph.Node, maxDegree+1)
|
||||
for _, n := range nodes {
|
||||
deg := dv[n.ID()]
|
||||
d[deg] = append(d[deg], n)
|
||||
}
|
||||
|
||||
// Initialize k to 0.
|
||||
k := 0
|
||||
// Repeat n times:
|
||||
s = []int{0}
|
||||
for range nodes {
|
||||
// Scan the array cells D[0], D[1], ... until
|
||||
// finding an i for which D[i] is nonempty.
|
||||
var (
|
||||
i int
|
||||
di []graph.Node
|
||||
)
|
||||
for i, di = range d {
|
||||
if len(di) != 0 {
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
// Set k to max(k,i).
|
||||
if i > k {
|
||||
k = i
|
||||
s = append(s, make([]int, k-len(s)+1)...)
|
||||
}
|
||||
|
||||
// Select a vertex v from D[i]. Add v to the
|
||||
// beginning of L and remove it from D[i].
|
||||
var v graph.Node
|
||||
v, d[i] = di[len(di)-1], di[:len(di)-1]
|
||||
l = append(l, v)
|
||||
s[k]++
|
||||
delete(dv, v.ID())
|
||||
|
||||
// For each neighbor w of v not already in L,
|
||||
// subtract one from d_w and move w to the
|
||||
// cell of D corresponding to the new value of d_w.
|
||||
for _, w := range neighbours[v.ID()] {
|
||||
dw, ok := dv[w.ID()]
|
||||
if !ok {
|
||||
continue
|
||||
}
|
||||
for i, n := range d[dw] {
|
||||
if n.ID() == w.ID() {
|
||||
d[dw][i], d[dw] = d[dw][len(d[dw])-1], d[dw][:len(d[dw])-1]
|
||||
dw--
|
||||
d[dw] = append(d[dw], w)
|
||||
break
|
||||
}
|
||||
}
|
||||
dv[w.ID()] = dw
|
||||
}
|
||||
}
|
||||
|
||||
return l, s
|
||||
}
|
||||
|
||||
// BronKerbosch returns the set of maximal cliques of the undirected graph g.
|
||||
func BronKerbosch(g graph.Undirected) [][]graph.Node {
|
||||
nodes := graph.NodesOf(g.Nodes())
|
||||
|
||||
// The algorithm used here is essentially BronKerbosch3 as described at
|
||||
// http://en.wikipedia.org/w/index.php?title=Bron%E2%80%93Kerbosch_algorithm&oldid=656805858
|
||||
|
||||
p := set.NewNodesSize(len(nodes))
|
||||
for _, n := range nodes {
|
||||
p.Add(n)
|
||||
}
|
||||
x := set.NewNodes()
|
||||
var bk bronKerbosch
|
||||
order, _ := degeneracyOrdering(g)
|
||||
ordered.Reverse(order)
|
||||
for _, v := range order {
|
||||
neighbours := graph.NodesOf(g.From(v.ID()))
|
||||
nv := set.NewNodesSize(len(neighbours))
|
||||
for _, n := range neighbours {
|
||||
nv.Add(n)
|
||||
}
|
||||
bk.maximalCliquePivot(g, []graph.Node{v}, set.IntersectionOfNodes(p, nv), set.IntersectionOfNodes(x, nv))
|
||||
p.Remove(v)
|
||||
x.Add(v)
|
||||
}
|
||||
return bk
|
||||
}
|
||||
|
||||
type bronKerbosch [][]graph.Node
|
||||
|
||||
func (bk *bronKerbosch) maximalCliquePivot(g graph.Undirected, r []graph.Node, p, x set.Nodes) {
|
||||
if len(p) == 0 && len(x) == 0 {
|
||||
*bk = append(*bk, r)
|
||||
return
|
||||
}
|
||||
|
||||
neighbours := bk.choosePivotFrom(g, p, x)
|
||||
nu := set.NewNodesSize(len(neighbours))
|
||||
for _, n := range neighbours {
|
||||
nu.Add(n)
|
||||
}
|
||||
for _, v := range p {
|
||||
if nu.Has(v) {
|
||||
continue
|
||||
}
|
||||
vid := v.ID()
|
||||
neighbours := graph.NodesOf(g.From(vid))
|
||||
nv := set.NewNodesSize(len(neighbours))
|
||||
for _, n := range neighbours {
|
||||
nv.Add(n)
|
||||
}
|
||||
|
||||
var found bool
|
||||
for _, n := range r {
|
||||
if n.ID() == vid {
|
||||
found = true
|
||||
break
|
||||
}
|
||||
}
|
||||
var sr []graph.Node
|
||||
if !found {
|
||||
sr = append(r[:len(r):len(r)], v)
|
||||
}
|
||||
|
||||
bk.maximalCliquePivot(g, sr, set.IntersectionOfNodes(p, nv), set.IntersectionOfNodes(x, nv))
|
||||
p.Remove(v)
|
||||
x.Add(v)
|
||||
}
|
||||
}
|
||||
|
||||
func (*bronKerbosch) choosePivotFrom(g graph.Undirected, p, x set.Nodes) (neighbors []graph.Node) {
|
||||
// TODO(kortschak): Investigate the impact of pivot choice that maximises
|
||||
// |p ⋂ neighbours(u)| as a function of input size. Until then, leave as
|
||||
// compile time option.
|
||||
if !tomitaTanakaTakahashi {
|
||||
for _, n := range p {
|
||||
return graph.NodesOf(g.From(n.ID()))
|
||||
}
|
||||
for _, n := range x {
|
||||
return graph.NodesOf(g.From(n.ID()))
|
||||
}
|
||||
panic("bronKerbosch: empty set")
|
||||
}
|
||||
|
||||
var (
|
||||
max = -1
|
||||
pivot graph.Node
|
||||
)
|
||||
maxNeighbors := func(s set.Nodes) {
|
||||
outer:
|
||||
for _, u := range s {
|
||||
nb := graph.NodesOf(g.From(u.ID()))
|
||||
c := len(nb)
|
||||
if c <= max {
|
||||
continue
|
||||
}
|
||||
for n := range nb {
|
||||
if _, ok := p[int64(n)]; ok {
|
||||
continue
|
||||
}
|
||||
c--
|
||||
if c <= max {
|
||||
continue outer
|
||||
}
|
||||
}
|
||||
max = c
|
||||
pivot = u
|
||||
neighbors = nb
|
||||
}
|
||||
}
|
||||
maxNeighbors(p)
|
||||
maxNeighbors(x)
|
||||
if pivot == nil {
|
||||
panic("bronKerbosch: empty set")
|
||||
}
|
||||
return neighbors
|
||||
}
|
||||
111
vendor/gonum.org/v1/gonum/graph/topo/clique_graph.go
generated
vendored
Normal file
111
vendor/gonum.org/v1/gonum/graph/topo/clique_graph.go
generated
vendored
Normal file
@@ -0,0 +1,111 @@
|
||||
// Copyright ©2017 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package topo
|
||||
|
||||
import (
|
||||
"sort"
|
||||
|
||||
"gonum.org/v1/gonum/graph"
|
||||
"gonum.org/v1/gonum/graph/internal/ordered"
|
||||
"gonum.org/v1/gonum/graph/internal/set"
|
||||
)
|
||||
|
||||
// Builder is a pure topological graph construction type.
|
||||
type Builder interface {
|
||||
AddNode(graph.Node)
|
||||
SetEdge(graph.Edge)
|
||||
}
|
||||
|
||||
// CliqueGraph builds the clique graph of g in dst using Clique and CliqueGraphEdge
|
||||
// nodes and edges. The nodes returned by calls to Nodes on the nodes and edges of
|
||||
// the constructed graph are the cliques and the common nodes between cliques
|
||||
// respectively. The dst graph is not cleared.
|
||||
func CliqueGraph(dst Builder, g graph.Undirected) {
|
||||
cliques := BronKerbosch(g)
|
||||
|
||||
// Construct a consistent view of cliques in g. Sorting costs
|
||||
// us a little, but not as much as the cliques themselves.
|
||||
for _, c := range cliques {
|
||||
sort.Sort(ordered.ByID(c))
|
||||
}
|
||||
sort.Sort(ordered.BySliceIDs(cliques))
|
||||
|
||||
cliqueNodes := make(cliqueNodeSets, len(cliques))
|
||||
for id, c := range cliques {
|
||||
s := set.NewNodesSize(len(c))
|
||||
for _, n := range c {
|
||||
s.Add(n)
|
||||
}
|
||||
ns := &nodeSet{Clique: Clique{id: int64(id), nodes: c}, nodes: s}
|
||||
dst.AddNode(ns.Clique)
|
||||
for _, n := range c {
|
||||
nid := n.ID()
|
||||
cliqueNodes[nid] = append(cliqueNodes[nid], ns)
|
||||
}
|
||||
}
|
||||
|
||||
for _, cliques := range cliqueNodes {
|
||||
for i, uc := range cliques {
|
||||
for _, vc := range cliques[i+1:] {
|
||||
// Retain the nodes that contribute to the
|
||||
// edge between the cliques.
|
||||
var edgeNodes []graph.Node
|
||||
switch 1 {
|
||||
case len(uc.Clique.nodes):
|
||||
edgeNodes = []graph.Node{uc.Clique.nodes[0]}
|
||||
case len(vc.Clique.nodes):
|
||||
edgeNodes = []graph.Node{vc.Clique.nodes[0]}
|
||||
default:
|
||||
for _, n := range set.IntersectionOfNodes(uc.nodes, vc.nodes) {
|
||||
edgeNodes = append(edgeNodes, n)
|
||||
}
|
||||
sort.Sort(ordered.ByID(edgeNodes))
|
||||
}
|
||||
|
||||
dst.SetEdge(CliqueGraphEdge{from: uc.Clique, to: vc.Clique, nodes: edgeNodes})
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
type cliqueNodeSets map[int64][]*nodeSet
|
||||
|
||||
type nodeSet struct {
|
||||
Clique
|
||||
nodes set.Nodes
|
||||
}
|
||||
|
||||
// Clique is a node in a clique graph.
|
||||
type Clique struct {
|
||||
id int64
|
||||
nodes []graph.Node
|
||||
}
|
||||
|
||||
// ID returns the node ID.
|
||||
func (n Clique) ID() int64 { return n.id }
|
||||
|
||||
// Nodes returns the nodes in the clique.
|
||||
func (n Clique) Nodes() []graph.Node { return n.nodes }
|
||||
|
||||
// CliqueGraphEdge is an edge in a clique graph.
|
||||
type CliqueGraphEdge struct {
|
||||
from, to Clique
|
||||
nodes []graph.Node
|
||||
}
|
||||
|
||||
// From returns the from node of the edge.
|
||||
func (e CliqueGraphEdge) From() graph.Node { return e.from }
|
||||
|
||||
// To returns the to node of the edge.
|
||||
func (e CliqueGraphEdge) To() graph.Node { return e.to }
|
||||
|
||||
// ReversedEdge returns a new CliqueGraphEdge with
|
||||
// the edge end points swapped. The nodes of the
|
||||
// new edge are shared with the receiver.
|
||||
func (e CliqueGraphEdge) ReversedEdge() graph.Edge { e.from, e.to = e.to, e.from; return e }
|
||||
|
||||
// Nodes returns the common nodes in the cliques of the underlying graph
|
||||
// corresponding to the from and to nodes in the clique graph.
|
||||
func (e CliqueGraphEdge) Nodes() []graph.Node { return e.nodes }
|
||||
6
vendor/gonum.org/v1/gonum/graph/topo/doc.go
generated
vendored
Normal file
6
vendor/gonum.org/v1/gonum/graph/topo/doc.go
generated
vendored
Normal file
@@ -0,0 +1,6 @@
|
||||
// Copyright ©2017 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
// Package topo provides graph topology analysis functions.
|
||||
package topo // import "gonum.org/v1/gonum/graph/topo"
|
||||
285
vendor/gonum.org/v1/gonum/graph/topo/johnson_cycles.go
generated
vendored
Normal file
285
vendor/gonum.org/v1/gonum/graph/topo/johnson_cycles.go
generated
vendored
Normal file
@@ -0,0 +1,285 @@
|
||||
// Copyright ©2015 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package topo
|
||||
|
||||
import (
|
||||
"sort"
|
||||
|
||||
"gonum.org/v1/gonum/graph"
|
||||
"gonum.org/v1/gonum/graph/internal/ordered"
|
||||
"gonum.org/v1/gonum/graph/internal/set"
|
||||
"gonum.org/v1/gonum/graph/iterator"
|
||||
)
|
||||
|
||||
// johnson implements Johnson's "Finding all the elementary
|
||||
// circuits of a directed graph" algorithm. SIAM J. Comput. 4(1):1975.
|
||||
//
|
||||
// Comments in the johnson methods are kept in sync with the comments
|
||||
// and labels from the paper.
|
||||
type johnson struct {
|
||||
adjacent johnsonGraph // SCC adjacency list.
|
||||
b []set.Ints // Johnson's "B-list".
|
||||
blocked []bool
|
||||
s int
|
||||
|
||||
stack []graph.Node
|
||||
|
||||
result [][]graph.Node
|
||||
}
|
||||
|
||||
// DirectedCyclesIn returns the set of elementary cycles in the graph g.
|
||||
func DirectedCyclesIn(g graph.Directed) [][]graph.Node {
|
||||
jg := johnsonGraphFrom(g)
|
||||
j := johnson{
|
||||
adjacent: jg,
|
||||
b: make([]set.Ints, len(jg.orig)),
|
||||
blocked: make([]bool, len(jg.orig)),
|
||||
}
|
||||
|
||||
// len(j.nodes) is the order of g.
|
||||
for j.s < len(j.adjacent.orig)-1 {
|
||||
// We use the previous SCC adjacency to reduce the work needed.
|
||||
sccs := TarjanSCC(j.adjacent.subgraph(j.s))
|
||||
// A_k = adjacency structure of strong component K with least
|
||||
// vertex in subgraph of G induced by {s, s+1, ... ,n}.
|
||||
j.adjacent = j.adjacent.sccSubGraph(sccs, 2) // Only allow SCCs with >= 2 vertices.
|
||||
if j.adjacent.order() == 0 {
|
||||
break
|
||||
}
|
||||
|
||||
// s = least vertex in V_k
|
||||
if s := j.adjacent.leastVertexIndex(); s < j.s {
|
||||
j.s = s
|
||||
}
|
||||
for i, v := range j.adjacent.orig {
|
||||
if !j.adjacent.nodes.Has(v.ID()) {
|
||||
continue
|
||||
}
|
||||
if len(j.adjacent.succ[v.ID()]) > 0 {
|
||||
j.blocked[i] = false
|
||||
j.b[i] = make(set.Ints)
|
||||
}
|
||||
}
|
||||
//L3:
|
||||
_ = j.circuit(j.s)
|
||||
j.s++
|
||||
}
|
||||
|
||||
return j.result
|
||||
}
|
||||
|
||||
// circuit is the CIRCUIT sub-procedure in the paper.
|
||||
func (j *johnson) circuit(v int) bool {
|
||||
f := false
|
||||
n := j.adjacent.orig[v]
|
||||
j.stack = append(j.stack, n)
|
||||
j.blocked[v] = true
|
||||
|
||||
//L1:
|
||||
for w := range j.adjacent.succ[n.ID()] {
|
||||
w := j.adjacent.indexOf(w)
|
||||
if w == j.s {
|
||||
// Output circuit composed of stack followed by s.
|
||||
r := make([]graph.Node, len(j.stack)+1)
|
||||
copy(r, j.stack)
|
||||
r[len(r)-1] = j.adjacent.orig[j.s]
|
||||
j.result = append(j.result, r)
|
||||
f = true
|
||||
} else if !j.blocked[w] {
|
||||
if j.circuit(w) {
|
||||
f = true
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//L2:
|
||||
if f {
|
||||
j.unblock(v)
|
||||
} else {
|
||||
for w := range j.adjacent.succ[n.ID()] {
|
||||
j.b[j.adjacent.indexOf(w)].Add(v)
|
||||
}
|
||||
}
|
||||
j.stack = j.stack[:len(j.stack)-1]
|
||||
|
||||
return f
|
||||
}
|
||||
|
||||
// unblock is the UNBLOCK sub-procedure in the paper.
|
||||
func (j *johnson) unblock(u int) {
|
||||
j.blocked[u] = false
|
||||
for w := range j.b[u] {
|
||||
j.b[u].Remove(w)
|
||||
if j.blocked[w] {
|
||||
j.unblock(w)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// johnsonGraph is an edge list representation of a graph with helpers
|
||||
// necessary for Johnson's algorithm
|
||||
type johnsonGraph struct {
|
||||
// Keep the original graph nodes and a
|
||||
// look-up to into the non-sparse
|
||||
// collection of potentially sparse IDs.
|
||||
orig []graph.Node
|
||||
index map[int64]int
|
||||
|
||||
nodes set.Int64s
|
||||
succ map[int64]set.Int64s
|
||||
}
|
||||
|
||||
// johnsonGraphFrom returns a deep copy of the graph g.
|
||||
func johnsonGraphFrom(g graph.Directed) johnsonGraph {
|
||||
nodes := graph.NodesOf(g.Nodes())
|
||||
sort.Sort(ordered.ByID(nodes))
|
||||
c := johnsonGraph{
|
||||
orig: nodes,
|
||||
index: make(map[int64]int, len(nodes)),
|
||||
|
||||
nodes: make(set.Int64s, len(nodes)),
|
||||
succ: make(map[int64]set.Int64s),
|
||||
}
|
||||
for i, u := range nodes {
|
||||
uid := u.ID()
|
||||
c.index[uid] = i
|
||||
for _, v := range graph.NodesOf(g.From(uid)) {
|
||||
if c.succ[uid] == nil {
|
||||
c.succ[uid] = make(set.Int64s)
|
||||
c.nodes.Add(uid)
|
||||
}
|
||||
c.nodes.Add(v.ID())
|
||||
c.succ[uid].Add(v.ID())
|
||||
}
|
||||
}
|
||||
return c
|
||||
}
|
||||
|
||||
// order returns the order of the graph.
|
||||
func (g johnsonGraph) order() int { return g.nodes.Count() }
|
||||
|
||||
// indexOf returns the index of the retained node for the given node ID.
|
||||
func (g johnsonGraph) indexOf(id int64) int {
|
||||
return g.index[id]
|
||||
}
|
||||
|
||||
// leastVertexIndex returns the index into orig of the least vertex.
|
||||
func (g johnsonGraph) leastVertexIndex() int {
|
||||
for _, v := range g.orig {
|
||||
if g.nodes.Has(v.ID()) {
|
||||
return g.indexOf(v.ID())
|
||||
}
|
||||
}
|
||||
panic("johnsonCycles: empty set")
|
||||
}
|
||||
|
||||
// subgraph returns a subgraph of g induced by {s, s+1, ... , n}. The
|
||||
// subgraph is destructively generated in g.
|
||||
func (g johnsonGraph) subgraph(s int) johnsonGraph {
|
||||
sn := g.orig[s].ID()
|
||||
for u, e := range g.succ {
|
||||
if u < sn {
|
||||
g.nodes.Remove(u)
|
||||
delete(g.succ, u)
|
||||
continue
|
||||
}
|
||||
for v := range e {
|
||||
if v < sn {
|
||||
g.succ[u].Remove(v)
|
||||
}
|
||||
}
|
||||
}
|
||||
return g
|
||||
}
|
||||
|
||||
// sccSubGraph returns the graph of the tarjan's strongly connected
|
||||
// components with each SCC containing at least min vertices.
|
||||
// sccSubGraph returns nil if there is no SCC with at least min
|
||||
// members.
|
||||
func (g johnsonGraph) sccSubGraph(sccs [][]graph.Node, min int) johnsonGraph {
|
||||
if len(g.nodes) == 0 {
|
||||
g.nodes = nil
|
||||
g.succ = nil
|
||||
return g
|
||||
}
|
||||
sub := johnsonGraph{
|
||||
orig: g.orig,
|
||||
index: g.index,
|
||||
nodes: make(set.Int64s),
|
||||
succ: make(map[int64]set.Int64s),
|
||||
}
|
||||
|
||||
var n int
|
||||
for _, scc := range sccs {
|
||||
if len(scc) < min {
|
||||
continue
|
||||
}
|
||||
n++
|
||||
for _, u := range scc {
|
||||
for _, v := range scc {
|
||||
if _, ok := g.succ[u.ID()][v.ID()]; ok {
|
||||
if sub.succ[u.ID()] == nil {
|
||||
sub.succ[u.ID()] = make(set.Int64s)
|
||||
sub.nodes.Add(u.ID())
|
||||
}
|
||||
sub.nodes.Add(v.ID())
|
||||
sub.succ[u.ID()].Add(v.ID())
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if n == 0 {
|
||||
g.nodes = nil
|
||||
g.succ = nil
|
||||
return g
|
||||
}
|
||||
|
||||
return sub
|
||||
}
|
||||
|
||||
// Nodes is required to satisfy Tarjan.
|
||||
func (g johnsonGraph) Nodes() graph.Nodes {
|
||||
n := make([]graph.Node, 0, len(g.nodes))
|
||||
for id := range g.nodes {
|
||||
n = append(n, johnsonGraphNode(id))
|
||||
}
|
||||
return iterator.NewOrderedNodes(n)
|
||||
}
|
||||
|
||||
// Successors is required to satisfy Tarjan.
|
||||
func (g johnsonGraph) From(id int64) graph.Nodes {
|
||||
adj := g.succ[id]
|
||||
if len(adj) == 0 {
|
||||
return graph.Empty
|
||||
}
|
||||
succ := make([]graph.Node, 0, len(adj))
|
||||
for id := range adj {
|
||||
succ = append(succ, johnsonGraphNode(id))
|
||||
}
|
||||
return iterator.NewOrderedNodes(succ)
|
||||
}
|
||||
|
||||
func (johnsonGraph) Has(int64) bool {
|
||||
panic("topo: unintended use of johnsonGraph")
|
||||
}
|
||||
func (johnsonGraph) Node(int64) graph.Node {
|
||||
panic("topo: unintended use of johnsonGraph")
|
||||
}
|
||||
func (johnsonGraph) HasEdgeBetween(_, _ int64) bool {
|
||||
panic("topo: unintended use of johnsonGraph")
|
||||
}
|
||||
func (johnsonGraph) Edge(_, _ int64) graph.Edge {
|
||||
panic("topo: unintended use of johnsonGraph")
|
||||
}
|
||||
func (johnsonGraph) HasEdgeFromTo(_, _ int64) bool {
|
||||
panic("topo: unintended use of johnsonGraph")
|
||||
}
|
||||
func (johnsonGraph) To(int64) graph.Nodes {
|
||||
panic("topo: unintended use of johnsonGraph")
|
||||
}
|
||||
|
||||
type johnsonGraphNode int64
|
||||
|
||||
func (n johnsonGraphNode) ID() int64 { return int64(n) }
|
||||
9
vendor/gonum.org/v1/gonum/graph/topo/non_tomita_choice.go
generated
vendored
Normal file
9
vendor/gonum.org/v1/gonum/graph/topo/non_tomita_choice.go
generated
vendored
Normal file
@@ -0,0 +1,9 @@
|
||||
// Copyright ©2015 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
// +build !tomita
|
||||
|
||||
package topo
|
||||
|
||||
const tomitaTanakaTakahashi = false
|
||||
83
vendor/gonum.org/v1/gonum/graph/topo/paton_cycles.go
generated
vendored
Normal file
83
vendor/gonum.org/v1/gonum/graph/topo/paton_cycles.go
generated
vendored
Normal file
@@ -0,0 +1,83 @@
|
||||
// Copyright ©2017 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package topo
|
||||
|
||||
import (
|
||||
"gonum.org/v1/gonum/graph"
|
||||
"gonum.org/v1/gonum/graph/internal/linear"
|
||||
"gonum.org/v1/gonum/graph/internal/set"
|
||||
)
|
||||
|
||||
// UndirectedCyclesIn returns a set of cycles that forms a cycle basis in the graph g.
|
||||
// Any cycle in g can be constructed as a symmetric difference of its elements.
|
||||
func UndirectedCyclesIn(g graph.Undirected) [][]graph.Node {
|
||||
// From "An algorithm for finding a fundamental set of cycles of a graph"
|
||||
// https://doi.org/10.1145/363219.363232
|
||||
|
||||
var cycles [][]graph.Node
|
||||
done := make(set.Int64s)
|
||||
var tree linear.NodeStack
|
||||
nodes := g.Nodes()
|
||||
for nodes.Next() {
|
||||
n := nodes.Node()
|
||||
id := n.ID()
|
||||
if done.Has(id) {
|
||||
continue
|
||||
}
|
||||
done.Add(id)
|
||||
|
||||
tree = tree[:0]
|
||||
tree.Push(n)
|
||||
from := sets{id: set.Int64s{}}
|
||||
to := map[int64]graph.Node{id: n}
|
||||
|
||||
for tree.Len() != 0 {
|
||||
u := tree.Pop()
|
||||
uid := u.ID()
|
||||
adj := from[uid]
|
||||
for _, v := range graph.NodesOf(g.From(uid)) {
|
||||
vid := v.ID()
|
||||
switch {
|
||||
case uid == vid:
|
||||
cycles = append(cycles, []graph.Node{u})
|
||||
case !from.has(vid):
|
||||
done.Add(vid)
|
||||
to[vid] = u
|
||||
tree.Push(v)
|
||||
from.add(uid, vid)
|
||||
case !adj.Has(vid):
|
||||
c := []graph.Node{v, u}
|
||||
adj := from[vid]
|
||||
p := to[uid]
|
||||
for !adj.Has(p.ID()) {
|
||||
c = append(c, p)
|
||||
p = to[p.ID()]
|
||||
}
|
||||
c = append(c, p, c[0])
|
||||
cycles = append(cycles, c)
|
||||
adj.Add(uid)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return cycles
|
||||
}
|
||||
|
||||
type sets map[int64]set.Int64s
|
||||
|
||||
func (s sets) add(uid, vid int64) {
|
||||
e, ok := s[vid]
|
||||
if !ok {
|
||||
e = make(set.Int64s)
|
||||
s[vid] = e
|
||||
}
|
||||
e.Add(uid)
|
||||
}
|
||||
|
||||
func (s sets) has(uid int64) bool {
|
||||
_, ok := s[uid]
|
||||
return ok
|
||||
}
|
||||
199
vendor/gonum.org/v1/gonum/graph/topo/tarjan.go
generated
vendored
Normal file
199
vendor/gonum.org/v1/gonum/graph/topo/tarjan.go
generated
vendored
Normal file
@@ -0,0 +1,199 @@
|
||||
// Copyright ©2015 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package topo
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"sort"
|
||||
|
||||
"gonum.org/v1/gonum/graph"
|
||||
"gonum.org/v1/gonum/graph/internal/ordered"
|
||||
"gonum.org/v1/gonum/graph/internal/set"
|
||||
)
|
||||
|
||||
// Unorderable is an error containing sets of unorderable graph.Nodes.
|
||||
type Unorderable [][]graph.Node
|
||||
|
||||
// Error satisfies the error interface.
|
||||
func (e Unorderable) Error() string {
|
||||
const maxNodes = 10
|
||||
var n int
|
||||
for _, c := range e {
|
||||
n += len(c)
|
||||
}
|
||||
if n > maxNodes {
|
||||
// Don't return errors that are too long.
|
||||
return fmt.Sprintf("topo: no topological ordering: %d nodes in %d cyclic components", n, len(e))
|
||||
}
|
||||
return fmt.Sprintf("topo: no topological ordering: cyclic components: %v", [][]graph.Node(e))
|
||||
}
|
||||
|
||||
func lexical(nodes []graph.Node) { sort.Sort(ordered.ByID(nodes)) }
|
||||
|
||||
// Sort performs a topological sort of the directed graph g returning the 'from' to 'to'
|
||||
// sort order. If a topological ordering is not possible, an Unorderable error is returned
|
||||
// listing cyclic components in g with each cyclic component's members sorted by ID. When
|
||||
// an Unorderable error is returned, each cyclic component's topological position within
|
||||
// the sorted nodes is marked with a nil graph.Node.
|
||||
func Sort(g graph.Directed) (sorted []graph.Node, err error) {
|
||||
sccs := TarjanSCC(g)
|
||||
return sortedFrom(sccs, lexical)
|
||||
}
|
||||
|
||||
// SortStabilized performs a topological sort of the directed graph g returning the 'from'
|
||||
// to 'to' sort order, or the order defined by the in place order sort function where there
|
||||
// is no unambiguous topological ordering. If a topological ordering is not possible, an
|
||||
// Unorderable error is returned listing cyclic components in g with each cyclic component's
|
||||
// members sorted by the provided order function. If order is nil, nodes are ordered lexically
|
||||
// by node ID. When an Unorderable error is returned, each cyclic component's topological
|
||||
// position within the sorted nodes is marked with a nil graph.Node.
|
||||
func SortStabilized(g graph.Directed, order func([]graph.Node)) (sorted []graph.Node, err error) {
|
||||
if order == nil {
|
||||
order = lexical
|
||||
}
|
||||
sccs := tarjanSCCstabilized(g, order)
|
||||
return sortedFrom(sccs, order)
|
||||
}
|
||||
|
||||
func sortedFrom(sccs [][]graph.Node, order func([]graph.Node)) ([]graph.Node, error) {
|
||||
sorted := make([]graph.Node, 0, len(sccs))
|
||||
var sc Unorderable
|
||||
for _, s := range sccs {
|
||||
if len(s) != 1 {
|
||||
order(s)
|
||||
sc = append(sc, s)
|
||||
sorted = append(sorted, nil)
|
||||
continue
|
||||
}
|
||||
sorted = append(sorted, s[0])
|
||||
}
|
||||
var err error
|
||||
if sc != nil {
|
||||
for i, j := 0, len(sc)-1; i < j; i, j = i+1, j-1 {
|
||||
sc[i], sc[j] = sc[j], sc[i]
|
||||
}
|
||||
err = sc
|
||||
}
|
||||
ordered.Reverse(sorted)
|
||||
return sorted, err
|
||||
}
|
||||
|
||||
// TarjanSCC returns the strongly connected components of the graph g using Tarjan's algorithm.
|
||||
//
|
||||
// A strongly connected component of a graph is a set of vertices where it's possible to reach any
|
||||
// vertex in the set from any other (meaning there's a cycle between them.)
|
||||
//
|
||||
// Generally speaking, a directed graph where the number of strongly connected components is equal
|
||||
// to the number of nodes is acyclic, unless you count reflexive edges as a cycle (which requires
|
||||
// only a little extra testing.)
|
||||
//
|
||||
func TarjanSCC(g graph.Directed) [][]graph.Node {
|
||||
return tarjanSCCstabilized(g, nil)
|
||||
}
|
||||
|
||||
func tarjanSCCstabilized(g graph.Directed, order func([]graph.Node)) [][]graph.Node {
|
||||
nodes := graph.NodesOf(g.Nodes())
|
||||
var succ func(id int64) []graph.Node
|
||||
if order == nil {
|
||||
succ = func(id int64) []graph.Node {
|
||||
return graph.NodesOf(g.From(id))
|
||||
}
|
||||
} else {
|
||||
order(nodes)
|
||||
ordered.Reverse(nodes)
|
||||
|
||||
succ = func(id int64) []graph.Node {
|
||||
to := graph.NodesOf(g.From(id))
|
||||
order(to)
|
||||
ordered.Reverse(to)
|
||||
return to
|
||||
}
|
||||
}
|
||||
|
||||
t := tarjan{
|
||||
succ: succ,
|
||||
|
||||
indexTable: make(map[int64]int, len(nodes)),
|
||||
lowLink: make(map[int64]int, len(nodes)),
|
||||
onStack: make(set.Int64s),
|
||||
}
|
||||
for _, v := range nodes {
|
||||
if t.indexTable[v.ID()] == 0 {
|
||||
t.strongconnect(v)
|
||||
}
|
||||
}
|
||||
return t.sccs
|
||||
}
|
||||
|
||||
// tarjan implements Tarjan's strongly connected component finding
|
||||
// algorithm. The implementation is from the pseudocode at
|
||||
//
|
||||
// http://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm?oldid=642744644
|
||||
//
|
||||
type tarjan struct {
|
||||
succ func(id int64) []graph.Node
|
||||
|
||||
index int
|
||||
indexTable map[int64]int
|
||||
lowLink map[int64]int
|
||||
onStack set.Int64s
|
||||
|
||||
stack []graph.Node
|
||||
|
||||
sccs [][]graph.Node
|
||||
}
|
||||
|
||||
// strongconnect is the strongconnect function described in the
|
||||
// wikipedia article.
|
||||
func (t *tarjan) strongconnect(v graph.Node) {
|
||||
vID := v.ID()
|
||||
|
||||
// Set the depth index for v to the smallest unused index.
|
||||
t.index++
|
||||
t.indexTable[vID] = t.index
|
||||
t.lowLink[vID] = t.index
|
||||
t.stack = append(t.stack, v)
|
||||
t.onStack.Add(vID)
|
||||
|
||||
// Consider successors of v.
|
||||
for _, w := range t.succ(vID) {
|
||||
wID := w.ID()
|
||||
if t.indexTable[wID] == 0 {
|
||||
// Successor w has not yet been visited; recur on it.
|
||||
t.strongconnect(w)
|
||||
t.lowLink[vID] = min(t.lowLink[vID], t.lowLink[wID])
|
||||
} else if t.onStack.Has(wID) {
|
||||
// Successor w is in stack s and hence in the current SCC.
|
||||
t.lowLink[vID] = min(t.lowLink[vID], t.indexTable[wID])
|
||||
}
|
||||
}
|
||||
|
||||
// If v is a root node, pop the stack and generate an SCC.
|
||||
if t.lowLink[vID] == t.indexTable[vID] {
|
||||
// Start a new strongly connected component.
|
||||
var (
|
||||
scc []graph.Node
|
||||
w graph.Node
|
||||
)
|
||||
for {
|
||||
w, t.stack = t.stack[len(t.stack)-1], t.stack[:len(t.stack)-1]
|
||||
t.onStack.Remove(w.ID())
|
||||
// Add w to current strongly connected component.
|
||||
scc = append(scc, w)
|
||||
if w.ID() == vID {
|
||||
break
|
||||
}
|
||||
}
|
||||
// Output the current strongly connected component.
|
||||
t.sccs = append(t.sccs, scc)
|
||||
}
|
||||
}
|
||||
|
||||
func min(a, b int) int {
|
||||
if a < b {
|
||||
return a
|
||||
}
|
||||
return b
|
||||
}
|
||||
9
vendor/gonum.org/v1/gonum/graph/topo/tomita_choice.go
generated
vendored
Normal file
9
vendor/gonum.org/v1/gonum/graph/topo/tomita_choice.go
generated
vendored
Normal file
@@ -0,0 +1,9 @@
|
||||
// Copyright ©2015 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
// +build tomita
|
||||
|
||||
package topo
|
||||
|
||||
const tomitaTanakaTakahashi = true
|
||||
68
vendor/gonum.org/v1/gonum/graph/topo/topo.go
generated
vendored
Normal file
68
vendor/gonum.org/v1/gonum/graph/topo/topo.go
generated
vendored
Normal file
@@ -0,0 +1,68 @@
|
||||
// Copyright ©2014 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package topo
|
||||
|
||||
import (
|
||||
"gonum.org/v1/gonum/graph"
|
||||
"gonum.org/v1/gonum/graph/traverse"
|
||||
)
|
||||
|
||||
// IsPathIn returns whether path is a path in g.
|
||||
//
|
||||
// As special cases, IsPathIn returns true for a zero length path or for
|
||||
// a path of length 1 when the node in path exists in the graph.
|
||||
func IsPathIn(g graph.Graph, path []graph.Node) bool {
|
||||
switch len(path) {
|
||||
case 0:
|
||||
return true
|
||||
case 1:
|
||||
return g.Node(path[0].ID()) != nil
|
||||
default:
|
||||
var canReach func(uid, vid int64) bool
|
||||
switch g := g.(type) {
|
||||
case graph.Directed:
|
||||
canReach = g.HasEdgeFromTo
|
||||
default:
|
||||
canReach = g.HasEdgeBetween
|
||||
}
|
||||
|
||||
for i, u := range path[:len(path)-1] {
|
||||
if !canReach(u.ID(), path[i+1].ID()) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
}
|
||||
|
||||
// PathExistsIn returns whether there is a path in g starting at from extending
|
||||
// to to.
|
||||
//
|
||||
// PathExistsIn exists as a helper function. If many tests for path existence
|
||||
// are being performed, other approaches will be more efficient.
|
||||
func PathExistsIn(g graph.Graph, from, to graph.Node) bool {
|
||||
var t traverse.BreadthFirst
|
||||
return t.Walk(g, from, func(n graph.Node, _ int) bool { return n.ID() == to.ID() }) != nil
|
||||
}
|
||||
|
||||
// ConnectedComponents returns the connected components of the undirected graph g.
|
||||
func ConnectedComponents(g graph.Undirected) [][]graph.Node {
|
||||
var (
|
||||
w traverse.DepthFirst
|
||||
c []graph.Node
|
||||
cc [][]graph.Node
|
||||
)
|
||||
during := func(n graph.Node) {
|
||||
c = append(c, n)
|
||||
}
|
||||
after := func() {
|
||||
cc = append(cc, []graph.Node(nil))
|
||||
cc[len(cc)-1] = append(cc[len(cc)-1], c...)
|
||||
c = c[:0]
|
||||
}
|
||||
w.WalkAll(g, nil, after, during)
|
||||
|
||||
return cc
|
||||
}
|
||||
6
vendor/gonum.org/v1/gonum/graph/traverse/doc.go
generated
vendored
Normal file
6
vendor/gonum.org/v1/gonum/graph/traverse/doc.go
generated
vendored
Normal file
@@ -0,0 +1,6 @@
|
||||
// Copyright ©2017 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
// Package traverse provides basic graph traversal primitives.
|
||||
package traverse // import "gonum.org/v1/gonum/graph/traverse"
|
||||
231
vendor/gonum.org/v1/gonum/graph/traverse/traverse.go
generated
vendored
Normal file
231
vendor/gonum.org/v1/gonum/graph/traverse/traverse.go
generated
vendored
Normal file
@@ -0,0 +1,231 @@
|
||||
// Copyright ©2015 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package traverse
|
||||
|
||||
import (
|
||||
"gonum.org/v1/gonum/graph"
|
||||
"gonum.org/v1/gonum/graph/internal/linear"
|
||||
"gonum.org/v1/gonum/graph/internal/set"
|
||||
)
|
||||
|
||||
var _ Graph = graph.Graph(nil)
|
||||
|
||||
// Graph is the subset of graph.Graph necessary for graph traversal.
|
||||
type Graph interface {
|
||||
// From returns all nodes that can be reached directly
|
||||
// from the node with the given ID.
|
||||
From(id int64) graph.Nodes
|
||||
|
||||
// Edge returns the edge from u to v, with IDs uid and vid,
|
||||
// if such an edge exists and nil otherwise. The node v
|
||||
// must be directly reachable from u as defined by
|
||||
// the From method.
|
||||
Edge(uid, vid int64) graph.Edge
|
||||
}
|
||||
|
||||
// BreadthFirst implements stateful breadth-first graph traversal.
|
||||
type BreadthFirst struct {
|
||||
// Visit is called on all nodes on their first visit.
|
||||
Visit func(graph.Node)
|
||||
|
||||
// Traverse is called on all edges that may be traversed
|
||||
// during the walk. This includes edges that would hop to
|
||||
// an already visited node.
|
||||
//
|
||||
// The value returned by Traverse determines whether
|
||||
// an edge can be traversed during the walk.
|
||||
Traverse func(graph.Edge) bool
|
||||
|
||||
queue linear.NodeQueue
|
||||
visited set.Int64s
|
||||
}
|
||||
|
||||
// Walk performs a breadth-first traversal of the graph g starting from the given node,
|
||||
// depending on the Traverse field and the until parameter if they are non-nil.
|
||||
// The traversal follows edges for which Traverse(edge) is true and returns the first node
|
||||
// for which until(node, depth) is true. During the traversal, if the Visit field is
|
||||
// non-nil, it is called with each node the first time it is visited.
|
||||
func (b *BreadthFirst) Walk(g Graph, from graph.Node, until func(n graph.Node, d int) bool) graph.Node {
|
||||
if b.visited == nil {
|
||||
b.visited = make(set.Int64s)
|
||||
}
|
||||
b.queue.Enqueue(from)
|
||||
if b.Visit != nil && !b.visited.Has(from.ID()) {
|
||||
b.Visit(from)
|
||||
}
|
||||
b.visited.Add(from.ID())
|
||||
|
||||
var (
|
||||
depth int
|
||||
children int
|
||||
untilNext = 1
|
||||
)
|
||||
for b.queue.Len() > 0 {
|
||||
t := b.queue.Dequeue()
|
||||
if until != nil && until(t, depth) {
|
||||
return t
|
||||
}
|
||||
tid := t.ID()
|
||||
to := g.From(tid)
|
||||
for to.Next() {
|
||||
n := to.Node()
|
||||
nid := n.ID()
|
||||
if b.Traverse != nil && !b.Traverse(g.Edge(tid, nid)) {
|
||||
continue
|
||||
}
|
||||
if b.visited.Has(nid) {
|
||||
continue
|
||||
}
|
||||
if b.Visit != nil {
|
||||
b.Visit(n)
|
||||
}
|
||||
b.visited.Add(nid)
|
||||
children++
|
||||
b.queue.Enqueue(n)
|
||||
}
|
||||
if untilNext--; untilNext == 0 {
|
||||
depth++
|
||||
untilNext = children
|
||||
children = 0
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// WalkAll calls Walk for each unvisited node of the graph g using edges independent
|
||||
// of their direction. The functions before and after are called prior to commencing
|
||||
// and after completing each walk if they are non-nil respectively. The function
|
||||
// during is called on each node as it is traversed.
|
||||
func (b *BreadthFirst) WalkAll(g graph.Undirected, before, after func(), during func(graph.Node)) {
|
||||
b.Reset()
|
||||
nodes := g.Nodes()
|
||||
for nodes.Next() {
|
||||
from := nodes.Node()
|
||||
if b.Visited(from) {
|
||||
continue
|
||||
}
|
||||
if before != nil {
|
||||
before()
|
||||
}
|
||||
b.Walk(g, from, func(n graph.Node, _ int) bool {
|
||||
if during != nil {
|
||||
during(n)
|
||||
}
|
||||
return false
|
||||
})
|
||||
if after != nil {
|
||||
after()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Visited returned whether the node n was visited during a traverse.
|
||||
func (b *BreadthFirst) Visited(n graph.Node) bool {
|
||||
return b.visited.Has(n.ID())
|
||||
}
|
||||
|
||||
// Reset resets the state of the traverser for reuse.
|
||||
func (b *BreadthFirst) Reset() {
|
||||
b.queue.Reset()
|
||||
b.visited = nil
|
||||
}
|
||||
|
||||
// DepthFirst implements stateful depth-first graph traversal.
|
||||
type DepthFirst struct {
|
||||
// Visit is called on all nodes on their first visit.
|
||||
Visit func(graph.Node)
|
||||
|
||||
// Traverse is called on all edges that may be traversed
|
||||
// during the walk. This includes edges that would hop to
|
||||
// an already visited node.
|
||||
//
|
||||
// The value returned by Traverse determines whether an
|
||||
// edge can be traversed during the walk.
|
||||
Traverse func(graph.Edge) bool
|
||||
|
||||
stack linear.NodeStack
|
||||
visited set.Int64s
|
||||
}
|
||||
|
||||
// Walk performs a depth-first traversal of the graph g starting from the given node,
|
||||
// depending on the Traverse field and the until parameter if they are non-nil.
|
||||
// The traversal follows edges for which Traverse(edge) is true and returns the first node
|
||||
// for which until(node) is true. During the traversal, if the Visit field is non-nil, it
|
||||
// is called with each node the first time it is visited.
|
||||
func (d *DepthFirst) Walk(g Graph, from graph.Node, until func(graph.Node) bool) graph.Node {
|
||||
if d.visited == nil {
|
||||
d.visited = make(set.Int64s)
|
||||
}
|
||||
d.stack.Push(from)
|
||||
if d.Visit != nil && !d.visited.Has(from.ID()) {
|
||||
d.Visit(from)
|
||||
}
|
||||
d.visited.Add(from.ID())
|
||||
|
||||
for d.stack.Len() > 0 {
|
||||
t := d.stack.Pop()
|
||||
if until != nil && until(t) {
|
||||
return t
|
||||
}
|
||||
tid := t.ID()
|
||||
to := g.From(tid)
|
||||
for to.Next() {
|
||||
n := to.Node()
|
||||
nid := n.ID()
|
||||
if d.Traverse != nil && !d.Traverse(g.Edge(tid, nid)) {
|
||||
continue
|
||||
}
|
||||
if d.visited.Has(nid) {
|
||||
continue
|
||||
}
|
||||
if d.Visit != nil {
|
||||
d.Visit(n)
|
||||
}
|
||||
d.visited.Add(nid)
|
||||
d.stack.Push(n)
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// WalkAll calls Walk for each unvisited node of the graph g using edges independent
|
||||
// of their direction. The functions before and after are called prior to commencing
|
||||
// and after completing each walk if they are non-nil respectively. The function
|
||||
// during is called on each node as it is traversed.
|
||||
func (d *DepthFirst) WalkAll(g graph.Undirected, before, after func(), during func(graph.Node)) {
|
||||
d.Reset()
|
||||
nodes := g.Nodes()
|
||||
for nodes.Next() {
|
||||
from := nodes.Node()
|
||||
if d.Visited(from) {
|
||||
continue
|
||||
}
|
||||
if before != nil {
|
||||
before()
|
||||
}
|
||||
d.Walk(g, from, func(n graph.Node) bool {
|
||||
if during != nil {
|
||||
during(n)
|
||||
}
|
||||
return false
|
||||
})
|
||||
if after != nil {
|
||||
after()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Visited returned whether the node n was visited during a traverse.
|
||||
func (d *DepthFirst) Visited(n graph.Node) bool {
|
||||
return d.visited.Has(n.ID())
|
||||
}
|
||||
|
||||
// Reset resets the state of the traverser for reuse.
|
||||
func (d *DepthFirst) Reset() {
|
||||
d.stack = d.stack[:0]
|
||||
d.visited = nil
|
||||
}
|
||||
270
vendor/gonum.org/v1/gonum/graph/undirect.go
generated
vendored
Normal file
270
vendor/gonum.org/v1/gonum/graph/undirect.go
generated
vendored
Normal file
@@ -0,0 +1,270 @@
|
||||
// Copyright ©2015 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package graph
|
||||
|
||||
// Undirect converts a directed graph to an undirected graph.
|
||||
type Undirect struct {
|
||||
G Directed
|
||||
}
|
||||
|
||||
var _ Undirected = Undirect{}
|
||||
|
||||
// Node returns the node with the given ID if it exists in the graph,
|
||||
// and nil otherwise.
|
||||
func (g Undirect) Node(id int64) Node { return g.G.Node(id) }
|
||||
|
||||
// Nodes returns all the nodes in the graph.
|
||||
func (g Undirect) Nodes() Nodes { return g.G.Nodes() }
|
||||
|
||||
// From returns all nodes in g that can be reached directly from u.
|
||||
func (g Undirect) From(uid int64) Nodes {
|
||||
return newNodeFilterIterator(g.G.From(uid), g.G.To(uid))
|
||||
}
|
||||
|
||||
// HasEdgeBetween returns whether an edge exists between nodes x and y.
|
||||
func (g Undirect) HasEdgeBetween(xid, yid int64) bool { return g.G.HasEdgeBetween(xid, yid) }
|
||||
|
||||
// Edge returns the edge from u to v if such an edge exists and nil otherwise.
|
||||
// The node v must be directly reachable from u as defined by the From method.
|
||||
// If an edge exists, the Edge returned is an EdgePair. The weight of
|
||||
// the edge is determined by applying the Merge func to the weights of the
|
||||
// edges between u and v.
|
||||
func (g Undirect) Edge(uid, vid int64) Edge { return g.EdgeBetween(uid, vid) }
|
||||
|
||||
// EdgeBetween returns the edge between nodes x and y. If an edge exists, the
|
||||
// Edge returned is an EdgePair. The weight of the edge is determined by
|
||||
// applying the Merge func to the weights of edges between x and y.
|
||||
func (g Undirect) EdgeBetween(xid, yid int64) Edge {
|
||||
fe := g.G.Edge(xid, yid)
|
||||
re := g.G.Edge(yid, xid)
|
||||
if fe == nil && re == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
return EdgePair{fe, re}
|
||||
}
|
||||
|
||||
// UndirectWeighted converts a directed weighted graph to an undirected weighted graph,
|
||||
// resolving edge weight conflicts.
|
||||
type UndirectWeighted struct {
|
||||
G WeightedDirected
|
||||
|
||||
// Absent is the value used to
|
||||
// represent absent edge weights
|
||||
// passed to Merge if the reverse
|
||||
// edge is present.
|
||||
Absent float64
|
||||
|
||||
// Merge defines how discordant edge
|
||||
// weights in G are resolved. A merge
|
||||
// is performed if at least one edge
|
||||
// exists between the nodes being
|
||||
// considered. The edges corresponding
|
||||
// to the two weights are also passed,
|
||||
// in the same order.
|
||||
// The order of weight parameters
|
||||
// passed to Merge is not defined, so
|
||||
// the function should be commutative.
|
||||
// If Merge is nil, the arithmetic
|
||||
// mean is used to merge weights.
|
||||
Merge func(x, y float64, xe, ye Edge) float64
|
||||
}
|
||||
|
||||
var (
|
||||
_ Undirected = UndirectWeighted{}
|
||||
_ WeightedUndirected = UndirectWeighted{}
|
||||
)
|
||||
|
||||
// Node returns the node with the given ID if it exists in the graph,
|
||||
// and nil otherwise.
|
||||
func (g UndirectWeighted) Node(id int64) Node { return g.G.Node(id) }
|
||||
|
||||
// Nodes returns all the nodes in the graph.
|
||||
func (g UndirectWeighted) Nodes() Nodes { return g.G.Nodes() }
|
||||
|
||||
// From returns all nodes in g that can be reached directly from u.
|
||||
func (g UndirectWeighted) From(uid int64) Nodes {
|
||||
return newNodeFilterIterator(g.G.From(uid), g.G.To(uid))
|
||||
}
|
||||
|
||||
// HasEdgeBetween returns whether an edge exists between nodes x and y.
|
||||
func (g UndirectWeighted) HasEdgeBetween(xid, yid int64) bool { return g.G.HasEdgeBetween(xid, yid) }
|
||||
|
||||
// Edge returns the edge from u to v if such an edge exists and nil otherwise.
|
||||
// The node v must be directly reachable from u as defined by the From method.
|
||||
// If an edge exists, the Edge returned is an EdgePair. The weight of
|
||||
// the edge is determined by applying the Merge func to the weights of the
|
||||
// edges between u and v.
|
||||
func (g UndirectWeighted) Edge(uid, vid int64) Edge { return g.WeightedEdgeBetween(uid, vid) }
|
||||
|
||||
// WeightedEdge returns the weighted edge from u to v if such an edge exists and nil otherwise.
|
||||
// The node v must be directly reachable from u as defined by the From method.
|
||||
// If an edge exists, the Edge returned is an EdgePair. The weight of
|
||||
// the edge is determined by applying the Merge func to the weights of the
|
||||
// edges between u and v.
|
||||
func (g UndirectWeighted) WeightedEdge(uid, vid int64) WeightedEdge {
|
||||
return g.WeightedEdgeBetween(uid, vid)
|
||||
}
|
||||
|
||||
// EdgeBetween returns the edge between nodes x and y. If an edge exists, the
|
||||
// Edge returned is an EdgePair. The weight of the edge is determined by
|
||||
// applying the Merge func to the weights of edges between x and y.
|
||||
func (g UndirectWeighted) EdgeBetween(xid, yid int64) Edge {
|
||||
return g.WeightedEdgeBetween(xid, yid)
|
||||
}
|
||||
|
||||
// WeightedEdgeBetween returns the weighted edge between nodes x and y. If an edge exists, the
|
||||
// Edge returned is an EdgePair. The weight of the edge is determined by
|
||||
// applying the Merge func to the weights of edges between x and y.
|
||||
func (g UndirectWeighted) WeightedEdgeBetween(xid, yid int64) WeightedEdge {
|
||||
fe := g.G.Edge(xid, yid)
|
||||
re := g.G.Edge(yid, xid)
|
||||
if fe == nil && re == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
f, ok := g.G.Weight(xid, yid)
|
||||
if !ok {
|
||||
f = g.Absent
|
||||
}
|
||||
r, ok := g.G.Weight(yid, xid)
|
||||
if !ok {
|
||||
r = g.Absent
|
||||
}
|
||||
|
||||
var w float64
|
||||
if g.Merge == nil {
|
||||
w = (f + r) / 2
|
||||
} else {
|
||||
w = g.Merge(f, r, fe, re)
|
||||
}
|
||||
return WeightedEdgePair{EdgePair: [2]Edge{fe, re}, W: w}
|
||||
}
|
||||
|
||||
// Weight returns the weight for the edge between x and y if Edge(x, y) returns a non-nil Edge.
|
||||
// If x and y are the same node the internal node weight is returned. If there is no joining
|
||||
// edge between the two nodes the weight value returned is zero. Weight returns true if an edge
|
||||
// exists between x and y or if x and y have the same ID, false otherwise.
|
||||
func (g UndirectWeighted) Weight(xid, yid int64) (w float64, ok bool) {
|
||||
fe := g.G.Edge(xid, yid)
|
||||
re := g.G.Edge(yid, xid)
|
||||
|
||||
f, fOk := g.G.Weight(xid, yid)
|
||||
if !fOk {
|
||||
f = g.Absent
|
||||
}
|
||||
r, rOK := g.G.Weight(yid, xid)
|
||||
if !rOK {
|
||||
r = g.Absent
|
||||
}
|
||||
ok = fOk || rOK
|
||||
|
||||
if g.Merge == nil {
|
||||
return (f + r) / 2, ok
|
||||
}
|
||||
return g.Merge(f, r, fe, re), ok
|
||||
}
|
||||
|
||||
// EdgePair is an opposed pair of directed edges.
|
||||
type EdgePair [2]Edge
|
||||
|
||||
// From returns the from node of the first non-nil edge, or nil.
|
||||
func (e EdgePair) From() Node {
|
||||
if e[0] != nil {
|
||||
return e[0].From()
|
||||
} else if e[1] != nil {
|
||||
return e[1].From()
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// To returns the to node of the first non-nil edge, or nil.
|
||||
func (e EdgePair) To() Node {
|
||||
if e[0] != nil {
|
||||
return e[0].To()
|
||||
} else if e[1] != nil {
|
||||
return e[1].To()
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// ReversedEdge returns a new Edge with the end point of the
|
||||
// edges in the pair swapped.
|
||||
func (e EdgePair) ReversedEdge() Edge {
|
||||
if e[0] != nil {
|
||||
e[0] = e[0].ReversedEdge()
|
||||
}
|
||||
if e[1] != nil {
|
||||
e[1] = e[1].ReversedEdge()
|
||||
}
|
||||
return e
|
||||
}
|
||||
|
||||
// WeightedEdgePair is an opposed pair of directed edges.
|
||||
type WeightedEdgePair struct {
|
||||
EdgePair
|
||||
W float64
|
||||
}
|
||||
|
||||
// ReversedEdge returns a new Edge with the end point of the
|
||||
// edges in the pair swapped.
|
||||
func (e WeightedEdgePair) ReversedEdge() Edge {
|
||||
e.EdgePair = e.EdgePair.ReversedEdge().(EdgePair)
|
||||
return e
|
||||
}
|
||||
|
||||
// Weight returns the merged edge weights of the two edges.
|
||||
func (e WeightedEdgePair) Weight() float64 { return e.W }
|
||||
|
||||
// nodeFilterIterator combines two Nodes to produce a single stream of
|
||||
// unique nodes.
|
||||
type nodeFilterIterator struct {
|
||||
a, b Nodes
|
||||
|
||||
// unique indicates the node in b with the key ID is unique.
|
||||
unique map[int64]bool
|
||||
}
|
||||
|
||||
func newNodeFilterIterator(a, b Nodes) *nodeFilterIterator {
|
||||
n := nodeFilterIterator{a: a, b: b, unique: make(map[int64]bool)}
|
||||
for n.b.Next() {
|
||||
n.unique[n.b.Node().ID()] = true
|
||||
}
|
||||
n.b.Reset()
|
||||
for n.a.Next() {
|
||||
n.unique[n.a.Node().ID()] = false
|
||||
}
|
||||
n.a.Reset()
|
||||
return &n
|
||||
}
|
||||
|
||||
func (n *nodeFilterIterator) Len() int {
|
||||
return len(n.unique)
|
||||
}
|
||||
|
||||
func (n *nodeFilterIterator) Next() bool {
|
||||
n.Len()
|
||||
if n.a.Next() {
|
||||
return true
|
||||
}
|
||||
for n.b.Next() {
|
||||
if n.unique[n.b.Node().ID()] {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func (n *nodeFilterIterator) Node() Node {
|
||||
if n.a.Len() != 0 {
|
||||
return n.a.Node()
|
||||
}
|
||||
return n.b.Node()
|
||||
}
|
||||
|
||||
func (n *nodeFilterIterator) Reset() {
|
||||
n.a.Reset()
|
||||
n.b.Reset()
|
||||
}
|
||||
134
vendor/gonum.org/v1/gonum/internal/asm/c128/axpyinc_amd64.s
generated
vendored
Normal file
134
vendor/gonum.org/v1/gonum/internal/asm/c128/axpyinc_amd64.s
generated
vendored
Normal file
@@ -0,0 +1,134 @@
|
||||
// Copyright ©2016 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
//+build !noasm,!appengine,!safe
|
||||
|
||||
#include "textflag.h"
|
||||
|
||||
// MOVDDUP X2, X3
|
||||
#define MOVDDUP_X2_X3 BYTE $0xF2; BYTE $0x0F; BYTE $0x12; BYTE $0xDA
|
||||
// MOVDDUP X4, X5
|
||||
#define MOVDDUP_X4_X5 BYTE $0xF2; BYTE $0x0F; BYTE $0x12; BYTE $0xEC
|
||||
// MOVDDUP X6, X7
|
||||
#define MOVDDUP_X6_X7 BYTE $0xF2; BYTE $0x0F; BYTE $0x12; BYTE $0xFE
|
||||
// MOVDDUP X8, X9
|
||||
#define MOVDDUP_X8_X9 BYTE $0xF2; BYTE $0x45; BYTE $0x0F; BYTE $0x12; BYTE $0xC8
|
||||
|
||||
// ADDSUBPD X2, X3
|
||||
#define ADDSUBPD_X2_X3 BYTE $0x66; BYTE $0x0F; BYTE $0xD0; BYTE $0xDA
|
||||
// ADDSUBPD X4, X5
|
||||
#define ADDSUBPD_X4_X5 BYTE $0x66; BYTE $0x0F; BYTE $0xD0; BYTE $0xEC
|
||||
// ADDSUBPD X6, X7
|
||||
#define ADDSUBPD_X6_X7 BYTE $0x66; BYTE $0x0F; BYTE $0xD0; BYTE $0xFE
|
||||
// ADDSUBPD X8, X9
|
||||
#define ADDSUBPD_X8_X9 BYTE $0x66; BYTE $0x45; BYTE $0x0F; BYTE $0xD0; BYTE $0xC8
|
||||
|
||||
// func AxpyInc(alpha complex128, x, y []complex128, n, incX, incY, ix, iy uintptr)
|
||||
TEXT ·AxpyInc(SB), NOSPLIT, $0
|
||||
MOVQ x_base+16(FP), SI // SI = &x
|
||||
MOVQ y_base+40(FP), DI // DI = &y
|
||||
MOVQ n+64(FP), CX // CX = n
|
||||
CMPQ CX, $0 // if n==0 { return }
|
||||
JE axpyi_end
|
||||
MOVQ ix+88(FP), R8 // R8 = ix // Load the first index
|
||||
SHLQ $4, R8 // R8 *= sizeof(complex128)
|
||||
MOVQ iy+96(FP), R9 // R9 = iy
|
||||
SHLQ $4, R9 // R9 *= sizeof(complex128)
|
||||
LEAQ (SI)(R8*1), SI // SI = &(x[ix])
|
||||
LEAQ (DI)(R9*1), DI // DI = &(y[iy])
|
||||
MOVQ DI, DX // DX = DI // Separate Read/Write pointers
|
||||
MOVQ incX+72(FP), R8 // R8 = incX
|
||||
SHLQ $4, R8 // R8 *= sizeof(complex128)
|
||||
MOVQ incY+80(FP), R9 // R9 = iy
|
||||
SHLQ $4, R9 // R9 *= sizeof(complex128)
|
||||
MOVUPS alpha+0(FP), X0 // X0 = { imag(a), real(a) }
|
||||
MOVAPS X0, X1
|
||||
SHUFPD $0x1, X1, X1 // X1 = { real(a), imag(a) }
|
||||
MOVAPS X0, X10 // Copy X0 and X1 for pipelining
|
||||
MOVAPS X1, X11
|
||||
MOVQ CX, BX
|
||||
ANDQ $3, CX // CX = n % 4
|
||||
SHRQ $2, BX // BX = floor( n / 4 )
|
||||
JZ axpyi_tail // if BX == 0 { goto axpyi_tail }
|
||||
|
||||
axpyi_loop: // do {
|
||||
MOVUPS (SI), X2 // X_i = { imag(x[i]), real(x[i]) }
|
||||
MOVUPS (SI)(R8*1), X4
|
||||
LEAQ (SI)(R8*2), SI // SI = &(SI[incX*2])
|
||||
MOVUPS (SI), X6
|
||||
MOVUPS (SI)(R8*1), X8
|
||||
|
||||
// X_(i+1) = { real(x[i], real(x[i]) }
|
||||
MOVDDUP_X2_X3
|
||||
MOVDDUP_X4_X5
|
||||
MOVDDUP_X6_X7
|
||||
MOVDDUP_X8_X9
|
||||
|
||||
// X_i = { imag(x[i]), imag(x[i]) }
|
||||
SHUFPD $0x3, X2, X2
|
||||
SHUFPD $0x3, X4, X4
|
||||
SHUFPD $0x3, X6, X6
|
||||
SHUFPD $0x3, X8, X8
|
||||
|
||||
// X_i = { real(a) * imag(x[i]), imag(a) * imag(x[i]) }
|
||||
// X_(i+1) = { imag(a) * real(x[i]), real(a) * real(x[i]) }
|
||||
MULPD X1, X2
|
||||
MULPD X0, X3
|
||||
MULPD X11, X4
|
||||
MULPD X10, X5
|
||||
MULPD X1, X6
|
||||
MULPD X0, X7
|
||||
MULPD X11, X8
|
||||
MULPD X10, X9
|
||||
|
||||
// X_(i+1) = {
|
||||
// imag(result[i]): imag(a)*real(x[i]) + real(a)*imag(x[i]),
|
||||
// real(result[i]): real(a)*real(x[i]) - imag(a)*imag(x[i])
|
||||
// }
|
||||
ADDSUBPD_X2_X3
|
||||
ADDSUBPD_X4_X5
|
||||
ADDSUBPD_X6_X7
|
||||
ADDSUBPD_X8_X9
|
||||
|
||||
// X_(i+1) = { imag(result[i]) + imag(y[i]), real(result[i]) + real(y[i]) }
|
||||
ADDPD (DX), X3
|
||||
ADDPD (DX)(R9*1), X5
|
||||
LEAQ (DX)(R9*2), DX // DX = &(DX[incY*2])
|
||||
ADDPD (DX), X7
|
||||
ADDPD (DX)(R9*1), X9
|
||||
MOVUPS X3, (DI) // dst[i] = X_(i+1)
|
||||
MOVUPS X5, (DI)(R9*1)
|
||||
LEAQ (DI)(R9*2), DI
|
||||
MOVUPS X7, (DI)
|
||||
MOVUPS X9, (DI)(R9*1)
|
||||
LEAQ (SI)(R8*2), SI // SI = &(SI[incX*2])
|
||||
LEAQ (DX)(R9*2), DX // DX = &(DX[incY*2])
|
||||
LEAQ (DI)(R9*2), DI // DI = &(DI[incY*2])
|
||||
DECQ BX
|
||||
JNZ axpyi_loop // } while --BX > 0
|
||||
CMPQ CX, $0 // if CX == 0 { return }
|
||||
JE axpyi_end
|
||||
|
||||
axpyi_tail: // do {
|
||||
MOVUPS (SI), X2 // X_i = { imag(x[i]), real(x[i]) }
|
||||
MOVDDUP_X2_X3 // X_(i+1) = { real(x[i], real(x[i]) }
|
||||
SHUFPD $0x3, X2, X2 // X_i = { imag(x[i]), imag(x[i]) }
|
||||
MULPD X1, X2 // X_i = { real(a) * imag(x[i]), imag(a) * imag(x[i]) }
|
||||
MULPD X0, X3 // X_(i+1) = { imag(a) * real(x[i]), real(a) * real(x[i]) }
|
||||
|
||||
// X_(i+1) = {
|
||||
// imag(result[i]): imag(a)*real(x[i]) + real(a)*imag(x[i]),
|
||||
// real(result[i]): real(a)*real(x[i]) - imag(a)*imag(x[i])
|
||||
// }
|
||||
ADDSUBPD_X2_X3
|
||||
|
||||
// X_(i+1) = { imag(result[i]) + imag(y[i]), real(result[i]) + real(y[i]) }
|
||||
ADDPD (DI), X3
|
||||
MOVUPS X3, (DI) // y[i] = X_i
|
||||
ADDQ R8, SI // SI = &(SI[incX])
|
||||
ADDQ R9, DI // DI = &(DI[incY])
|
||||
LOOP axpyi_tail // } while --CX > 0
|
||||
|
||||
axpyi_end:
|
||||
RET
|
||||
141
vendor/gonum.org/v1/gonum/internal/asm/c128/axpyincto_amd64.s
generated
vendored
Normal file
141
vendor/gonum.org/v1/gonum/internal/asm/c128/axpyincto_amd64.s
generated
vendored
Normal file
@@ -0,0 +1,141 @@
|
||||
// Copyright ©2016 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
//+build !noasm,!appengine,!safe
|
||||
|
||||
#include "textflag.h"
|
||||
|
||||
// MOVDDUP X2, X3
|
||||
#define MOVDDUP_X2_X3 BYTE $0xF2; BYTE $0x0F; BYTE $0x12; BYTE $0xDA
|
||||
// MOVDDUP X4, X5
|
||||
#define MOVDDUP_X4_X5 BYTE $0xF2; BYTE $0x0F; BYTE $0x12; BYTE $0xEC
|
||||
// MOVDDUP X6, X7
|
||||
#define MOVDDUP_X6_X7 BYTE $0xF2; BYTE $0x0F; BYTE $0x12; BYTE $0xFE
|
||||
// MOVDDUP X8, X9
|
||||
#define MOVDDUP_X8_X9 BYTE $0xF2; BYTE $0x45; BYTE $0x0F; BYTE $0x12; BYTE $0xC8
|
||||
|
||||
// ADDSUBPD X2, X3
|
||||
#define ADDSUBPD_X2_X3 BYTE $0x66; BYTE $0x0F; BYTE $0xD0; BYTE $0xDA
|
||||
// ADDSUBPD X4, X5
|
||||
#define ADDSUBPD_X4_X5 BYTE $0x66; BYTE $0x0F; BYTE $0xD0; BYTE $0xEC
|
||||
// ADDSUBPD X6, X7
|
||||
#define ADDSUBPD_X6_X7 BYTE $0x66; BYTE $0x0F; BYTE $0xD0; BYTE $0xFE
|
||||
// ADDSUBPD X8, X9
|
||||
#define ADDSUBPD_X8_X9 BYTE $0x66; BYTE $0x45; BYTE $0x0F; BYTE $0xD0; BYTE $0xC8
|
||||
|
||||
// func AxpyIncTo(dst []complex128, incDst, idst uintptr, alpha complex128, x, y []complex128, n, incX, incY, ix, iy uintptr)
|
||||
TEXT ·AxpyIncTo(SB), NOSPLIT, $0
|
||||
MOVQ dst_base+0(FP), DI // DI = &dst
|
||||
MOVQ x_base+56(FP), SI // SI = &x
|
||||
MOVQ y_base+80(FP), DX // DX = &y
|
||||
MOVQ n+104(FP), CX // CX = n
|
||||
CMPQ CX, $0 // if n==0 { return }
|
||||
JE axpyi_end
|
||||
MOVQ ix+128(FP), R8 // R8 = ix // Load the first index
|
||||
SHLQ $4, R8 // R8 *= sizeof(complex128)
|
||||
MOVQ iy+136(FP), R9 // R9 = iy
|
||||
SHLQ $4, R9 // R9 *= sizeof(complex128)
|
||||
MOVQ idst+32(FP), R10 // R10 = idst
|
||||
SHLQ $4, R10 // R10 *= sizeof(complex128)
|
||||
LEAQ (SI)(R8*1), SI // SI = &(x[ix])
|
||||
LEAQ (DX)(R9*1), DX // DX = &(y[iy])
|
||||
LEAQ (DI)(R10*1), DI // DI = &(dst[idst])
|
||||
MOVQ incX+112(FP), R8 // R8 = incX
|
||||
SHLQ $4, R8 // R8 *= sizeof(complex128)
|
||||
MOVQ incY+120(FP), R9 // R9 = incY
|
||||
SHLQ $4, R9 // R9 *= sizeof(complex128)
|
||||
MOVQ incDst+24(FP), R10 // R10 = incDst
|
||||
SHLQ $4, R10 // R10 *= sizeof(complex128)
|
||||
MOVUPS alpha+40(FP), X0 // X0 = { imag(a), real(a) }
|
||||
MOVAPS X0, X1
|
||||
SHUFPD $0x1, X1, X1 // X1 = { real(a), imag(a) }
|
||||
MOVAPS X0, X10 // Copy X0 and X1 for pipelining
|
||||
MOVAPS X1, X11
|
||||
MOVQ CX, BX
|
||||
ANDQ $3, CX // CX = n % 4
|
||||
SHRQ $2, BX // BX = floor( n / 4 )
|
||||
JZ axpyi_tail // if BX == 0 { goto axpyi_tail }
|
||||
|
||||
axpyi_loop: // do {
|
||||
MOVUPS (SI), X2 // X_i = { imag(x[i]), real(x[i]) }
|
||||
MOVUPS (SI)(R8*1), X4
|
||||
LEAQ (SI)(R8*2), SI // SI = &(SI[incX*2])
|
||||
|
||||
MOVUPS (SI), X6
|
||||
MOVUPS (SI)(R8*1), X8
|
||||
|
||||
// X_(i+1) = { real(x[i], real(x[i]) }
|
||||
MOVDDUP_X2_X3
|
||||
MOVDDUP_X4_X5
|
||||
MOVDDUP_X6_X7
|
||||
MOVDDUP_X8_X9
|
||||
|
||||
// X_i = { imag(x[i]), imag(x[i]) }
|
||||
SHUFPD $0x3, X2, X2
|
||||
SHUFPD $0x3, X4, X4
|
||||
SHUFPD $0x3, X6, X6
|
||||
SHUFPD $0x3, X8, X8
|
||||
|
||||
// X_i = { real(a) * imag(x[i]), imag(a) * imag(x[i]) }
|
||||
// X_(i+1) = { imag(a) * real(x[i]), real(a) * real(x[i]) }
|
||||
MULPD X1, X2
|
||||
MULPD X0, X3
|
||||
MULPD X11, X4
|
||||
MULPD X10, X5
|
||||
MULPD X1, X6
|
||||
MULPD X0, X7
|
||||
MULPD X11, X8
|
||||
MULPD X10, X9
|
||||
|
||||
// X_(i+1) = {
|
||||
// imag(result[i]): imag(a)*real(x[i]) + real(a)*imag(x[i]),
|
||||
// real(result[i]): real(a)*real(x[i]) - imag(a)*imag(x[i])
|
||||
// }
|
||||
ADDSUBPD_X2_X3
|
||||
ADDSUBPD_X4_X5
|
||||
ADDSUBPD_X6_X7
|
||||
ADDSUBPD_X8_X9
|
||||
|
||||
// X_(i+1) = { imag(result[i]) + imag(y[i]), real(result[i]) + real(y[i]) }
|
||||
ADDPD (DX), X3
|
||||
ADDPD (DX)(R9*1), X5
|
||||
LEAQ (DX)(R9*2), DX // DX = &(DX[incY*2])
|
||||
ADDPD (DX), X7
|
||||
ADDPD (DX)(R9*1), X9
|
||||
MOVUPS X3, (DI) // dst[i] = X_(i+1)
|
||||
MOVUPS X5, (DI)(R10*1)
|
||||
LEAQ (DI)(R10*2), DI
|
||||
MOVUPS X7, (DI)
|
||||
MOVUPS X9, (DI)(R10*1)
|
||||
LEAQ (SI)(R8*2), SI // SI = &(SI[incX*2])
|
||||
LEAQ (DX)(R9*2), DX // DX = &(DX[incY*2])
|
||||
LEAQ (DI)(R10*2), DI // DI = &(DI[incDst*2])
|
||||
DECQ BX
|
||||
JNZ axpyi_loop // } while --BX > 0
|
||||
CMPQ CX, $0 // if CX == 0 { return }
|
||||
JE axpyi_end
|
||||
|
||||
axpyi_tail: // do {
|
||||
MOVUPS (SI), X2 // X_i = { imag(x[i]), real(x[i]) }
|
||||
MOVDDUP_X2_X3 // X_(i+1) = { real(x[i], real(x[i]) }
|
||||
SHUFPD $0x3, X2, X2 // X_i = { imag(x[i]), imag(x[i]) }
|
||||
MULPD X1, X2 // X_i = { real(a) * imag(x[i]), imag(a) * imag(x[i]) }
|
||||
MULPD X0, X3 // X_(i+1) = { imag(a) * real(x[i]), real(a) * real(x[i]) }
|
||||
|
||||
// X_(i+1) = {
|
||||
// imag(result[i]): imag(a)*real(x[i]) + real(a)*imag(x[i]),
|
||||
// real(result[i]): real(a)*real(x[i]) - imag(a)*imag(x[i])
|
||||
// }
|
||||
ADDSUBPD_X2_X3
|
||||
|
||||
// X_(i+1) = { imag(result[i]) + imag(y[i]), real(result[i]) + real(y[i]) }
|
||||
ADDPD (DX), X3
|
||||
MOVUPS X3, (DI) // y[i] X_(i+1)
|
||||
ADDQ R8, SI // SI += incX
|
||||
ADDQ R9, DX // DX += incY
|
||||
ADDQ R10, DI // DI += incDst
|
||||
LOOP axpyi_tail // } while --CX > 0
|
||||
|
||||
axpyi_end:
|
||||
RET
|
||||
122
vendor/gonum.org/v1/gonum/internal/asm/c128/axpyunitary_amd64.s
generated
vendored
Normal file
122
vendor/gonum.org/v1/gonum/internal/asm/c128/axpyunitary_amd64.s
generated
vendored
Normal file
@@ -0,0 +1,122 @@
|
||||
// Copyright ©2016 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
//+build !noasm,!appengine,!safe
|
||||
|
||||
#include "textflag.h"
|
||||
|
||||
// MOVDDUP X2, X3
|
||||
#define MOVDDUP_X2_X3 BYTE $0xF2; BYTE $0x0F; BYTE $0x12; BYTE $0xDA
|
||||
// MOVDDUP X4, X5
|
||||
#define MOVDDUP_X4_X5 BYTE $0xF2; BYTE $0x0F; BYTE $0x12; BYTE $0xEC
|
||||
// MOVDDUP X6, X7
|
||||
#define MOVDDUP_X6_X7 BYTE $0xF2; BYTE $0x0F; BYTE $0x12; BYTE $0xFE
|
||||
// MOVDDUP X8, X9
|
||||
#define MOVDDUP_X8_X9 BYTE $0xF2; BYTE $0x45; BYTE $0x0F; BYTE $0x12; BYTE $0xC8
|
||||
|
||||
// ADDSUBPD X2, X3
|
||||
#define ADDSUBPD_X2_X3 BYTE $0x66; BYTE $0x0F; BYTE $0xD0; BYTE $0xDA
|
||||
// ADDSUBPD X4, X5
|
||||
#define ADDSUBPD_X4_X5 BYTE $0x66; BYTE $0x0F; BYTE $0xD0; BYTE $0xEC
|
||||
// ADDSUBPD X6, X7
|
||||
#define ADDSUBPD_X6_X7 BYTE $0x66; BYTE $0x0F; BYTE $0xD0; BYTE $0xFE
|
||||
// ADDSUBPD X8, X9
|
||||
#define ADDSUBPD_X8_X9 BYTE $0x66; BYTE $0x45; BYTE $0x0F; BYTE $0xD0; BYTE $0xC8
|
||||
|
||||
// func AxpyUnitary(alpha complex128, x, y []complex128)
|
||||
TEXT ·AxpyUnitary(SB), NOSPLIT, $0
|
||||
MOVQ x_base+16(FP), SI // SI = &x
|
||||
MOVQ y_base+40(FP), DI // DI = &y
|
||||
MOVQ x_len+24(FP), CX // CX = min( len(x), len(y) )
|
||||
CMPQ y_len+48(FP), CX
|
||||
CMOVQLE y_len+48(FP), CX
|
||||
CMPQ CX, $0 // if CX == 0 { return }
|
||||
JE caxy_end
|
||||
PXOR X0, X0 // Clear work registers and cache-align loop
|
||||
PXOR X1, X1
|
||||
MOVUPS alpha+0(FP), X0 // X0 = { imag(a), real(a) }
|
||||
MOVAPS X0, X1
|
||||
SHUFPD $0x1, X1, X1 // X1 = { real(a), imag(a) }
|
||||
XORQ AX, AX // i = 0
|
||||
MOVAPS X0, X10 // Copy X0 and X1 for pipelining
|
||||
MOVAPS X1, X11
|
||||
MOVQ CX, BX
|
||||
ANDQ $3, CX // CX = n % 4
|
||||
SHRQ $2, BX // BX = floor( n / 4 )
|
||||
JZ caxy_tail // if BX == 0 { goto caxy_tail }
|
||||
|
||||
caxy_loop: // do {
|
||||
MOVUPS (SI)(AX*8), X2 // X_i = { imag(x[i]), real(x[i]) }
|
||||
MOVUPS 16(SI)(AX*8), X4
|
||||
MOVUPS 32(SI)(AX*8), X6
|
||||
MOVUPS 48(SI)(AX*8), X8
|
||||
|
||||
// X_(i+1) = { real(x[i], real(x[i]) }
|
||||
MOVDDUP_X2_X3
|
||||
MOVDDUP_X4_X5
|
||||
MOVDDUP_X6_X7
|
||||
MOVDDUP_X8_X9
|
||||
|
||||
// X_i = { imag(x[i]), imag(x[i]) }
|
||||
SHUFPD $0x3, X2, X2
|
||||
SHUFPD $0x3, X4, X4
|
||||
SHUFPD $0x3, X6, X6
|
||||
SHUFPD $0x3, X8, X8
|
||||
|
||||
// X_i = { real(a) * imag(x[i]), imag(a) * imag(x[i]) }
|
||||
// X_(i+1) = { imag(a) * real(x[i]), real(a) * real(x[i]) }
|
||||
MULPD X1, X2
|
||||
MULPD X0, X3
|
||||
MULPD X11, X4
|
||||
MULPD X10, X5
|
||||
MULPD X1, X6
|
||||
MULPD X0, X7
|
||||
MULPD X11, X8
|
||||
MULPD X10, X9
|
||||
|
||||
// X_(i+1) = {
|
||||
// imag(result[i]): imag(a)*real(x[i]) + real(a)*imag(x[i]),
|
||||
// real(result[i]): real(a)*real(x[i]) - imag(a)*imag(x[i])
|
||||
// }
|
||||
ADDSUBPD_X2_X3
|
||||
ADDSUBPD_X4_X5
|
||||
ADDSUBPD_X6_X7
|
||||
ADDSUBPD_X8_X9
|
||||
|
||||
// X_(i+1) = { imag(result[i]) + imag(y[i]), real(result[i]) + real(y[i]) }
|
||||
ADDPD (DI)(AX*8), X3
|
||||
ADDPD 16(DI)(AX*8), X5
|
||||
ADDPD 32(DI)(AX*8), X7
|
||||
ADDPD 48(DI)(AX*8), X9
|
||||
MOVUPS X3, (DI)(AX*8) // y[i] = X_(i+1)
|
||||
MOVUPS X5, 16(DI)(AX*8)
|
||||
MOVUPS X7, 32(DI)(AX*8)
|
||||
MOVUPS X9, 48(DI)(AX*8)
|
||||
ADDQ $8, AX // i += 8
|
||||
DECQ BX
|
||||
JNZ caxy_loop // } while --BX > 0
|
||||
CMPQ CX, $0 // if CX == 0 { return }
|
||||
JE caxy_end
|
||||
|
||||
caxy_tail: // do {
|
||||
MOVUPS (SI)(AX*8), X2 // X_i = { imag(x[i]), real(x[i]) }
|
||||
MOVDDUP_X2_X3 // X_(i+1) = { real(x[i], real(x[i]) }
|
||||
SHUFPD $0x3, X2, X2 // X_i = { imag(x[i]), imag(x[i]) }
|
||||
MULPD X1, X2 // X_i = { real(a) * imag(x[i]), imag(a) * imag(x[i]) }
|
||||
MULPD X0, X3 // X_(i+1) = { imag(a) * real(x[i]), real(a) * real(x[i]) }
|
||||
|
||||
// X_(i+1) = {
|
||||
// imag(result[i]): imag(a)*real(x[i]) + real(a)*imag(x[i]),
|
||||
// real(result[i]): real(a)*real(x[i]) - imag(a)*imag(x[i])
|
||||
// }
|
||||
ADDSUBPD_X2_X3
|
||||
|
||||
// X_(i+1) = { imag(result[i]) + imag(y[i]), real(result[i]) + real(y[i]) }
|
||||
ADDPD (DI)(AX*8), X3
|
||||
MOVUPS X3, (DI)(AX*8) // y[i] = X_(i+1)
|
||||
ADDQ $2, AX // i += 2
|
||||
LOOP caxy_tail // } while --CX > 0
|
||||
|
||||
caxy_end:
|
||||
RET
|
||||
123
vendor/gonum.org/v1/gonum/internal/asm/c128/axpyunitaryto_amd64.s
generated
vendored
Normal file
123
vendor/gonum.org/v1/gonum/internal/asm/c128/axpyunitaryto_amd64.s
generated
vendored
Normal file
@@ -0,0 +1,123 @@
|
||||
// Copyright ©2016 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
//+build !noasm,!appengine,!safe
|
||||
|
||||
#include "textflag.h"
|
||||
|
||||
// MOVDDUP X2, X3
|
||||
#define MOVDDUP_X2_X3 BYTE $0xF2; BYTE $0x0F; BYTE $0x12; BYTE $0xDA
|
||||
// MOVDDUP X4, X5
|
||||
#define MOVDDUP_X4_X5 BYTE $0xF2; BYTE $0x0F; BYTE $0x12; BYTE $0xEC
|
||||
// MOVDDUP X6, X7
|
||||
#define MOVDDUP_X6_X7 BYTE $0xF2; BYTE $0x0F; BYTE $0x12; BYTE $0xFE
|
||||
// MOVDDUP X8, X9
|
||||
#define MOVDDUP_X8_X9 BYTE $0xF2; BYTE $0x45; BYTE $0x0F; BYTE $0x12; BYTE $0xC8
|
||||
|
||||
// ADDSUBPD X2, X3
|
||||
#define ADDSUBPD_X2_X3 BYTE $0x66; BYTE $0x0F; BYTE $0xD0; BYTE $0xDA
|
||||
// ADDSUBPD X4, X5
|
||||
#define ADDSUBPD_X4_X5 BYTE $0x66; BYTE $0x0F; BYTE $0xD0; BYTE $0xEC
|
||||
// ADDSUBPD X6, X7
|
||||
#define ADDSUBPD_X6_X7 BYTE $0x66; BYTE $0x0F; BYTE $0xD0; BYTE $0xFE
|
||||
// ADDSUBPD X8, X9
|
||||
#define ADDSUBPD_X8_X9 BYTE $0x66; BYTE $0x45; BYTE $0x0F; BYTE $0xD0; BYTE $0xC8
|
||||
|
||||
// func AxpyUnitaryTo(dst []complex128, alpha complex64, x, y []complex128)
|
||||
TEXT ·AxpyUnitaryTo(SB), NOSPLIT, $0
|
||||
MOVQ dst_base+0(FP), DI // DI = &dst
|
||||
MOVQ x_base+40(FP), SI // SI = &x
|
||||
MOVQ y_base+64(FP), DX // DX = &y
|
||||
MOVQ x_len+48(FP), CX // CX = min( len(x), len(y), len(dst) )
|
||||
CMPQ y_len+72(FP), CX
|
||||
CMOVQLE y_len+72(FP), CX
|
||||
CMPQ dst_len+8(FP), CX
|
||||
CMOVQLE dst_len+8(FP), CX
|
||||
CMPQ CX, $0 // if CX == 0 { return }
|
||||
JE caxy_end
|
||||
MOVUPS alpha+24(FP), X0 // X0 = { imag(a), real(a) }
|
||||
MOVAPS X0, X1
|
||||
SHUFPD $0x1, X1, X1 // X1 = { real(a), imag(a) }
|
||||
XORQ AX, AX // i = 0
|
||||
MOVAPS X0, X10 // Copy X0 and X1 for pipelining
|
||||
MOVAPS X1, X11
|
||||
MOVQ CX, BX
|
||||
ANDQ $3, CX // CX = n % 4
|
||||
SHRQ $2, BX // BX = floor( n / 4 )
|
||||
JZ caxy_tail // if BX == 0 { goto caxy_tail }
|
||||
|
||||
caxy_loop: // do {
|
||||
MOVUPS (SI)(AX*8), X2 // X_i = { imag(x[i]), real(x[i]) }
|
||||
MOVUPS 16(SI)(AX*8), X4
|
||||
MOVUPS 32(SI)(AX*8), X6
|
||||
MOVUPS 48(SI)(AX*8), X8
|
||||
|
||||
// X_(i+1) = { real(x[i], real(x[i]) }
|
||||
MOVDDUP_X2_X3 // Load and duplicate imag elements (xi, xi)
|
||||
MOVDDUP_X4_X5
|
||||
MOVDDUP_X6_X7
|
||||
MOVDDUP_X8_X9
|
||||
|
||||
// X_i = { imag(x[i]), imag(x[i]) }
|
||||
SHUFPD $0x3, X2, X2 // duplicate real elements (xr, xr)
|
||||
SHUFPD $0x3, X4, X4
|
||||
SHUFPD $0x3, X6, X6
|
||||
SHUFPD $0x3, X8, X8
|
||||
|
||||
// X_i = { real(a) * imag(x[i]), imag(a) * imag(x[i]) }
|
||||
// X_(i+1) = { imag(a) * real(x[i]), real(a) * real(x[i]) }
|
||||
MULPD X1, X2
|
||||
MULPD X0, X3
|
||||
MULPD X11, X4
|
||||
MULPD X10, X5
|
||||
MULPD X1, X6
|
||||
MULPD X0, X7
|
||||
MULPD X11, X8
|
||||
MULPD X10, X9
|
||||
|
||||
// X_(i+1) = {
|
||||
// imag(result[i]): imag(a)*real(x[i]) + real(a)*imag(x[i]),
|
||||
// real(result[i]): real(a)*real(x[i]) - imag(a)*imag(x[i])
|
||||
// }
|
||||
ADDSUBPD_X2_X3
|
||||
ADDSUBPD_X4_X5
|
||||
ADDSUBPD_X6_X7
|
||||
ADDSUBPD_X8_X9
|
||||
|
||||
// X_(i+1) = { imag(result[i]) + imag(y[i]), real(result[i]) + real(y[i]) }
|
||||
ADDPD (DX)(AX*8), X3
|
||||
ADDPD 16(DX)(AX*8), X5
|
||||
ADDPD 32(DX)(AX*8), X7
|
||||
ADDPD 48(DX)(AX*8), X9
|
||||
MOVUPS X3, (DI)(AX*8) // y[i] = X_(i+1)
|
||||
MOVUPS X5, 16(DI)(AX*8)
|
||||
MOVUPS X7, 32(DI)(AX*8)
|
||||
MOVUPS X9, 48(DI)(AX*8)
|
||||
ADDQ $8, AX // i += 8
|
||||
DECQ BX
|
||||
JNZ caxy_loop // } while --BX > 0
|
||||
CMPQ CX, $0 // if CX == 0 { return }
|
||||
JE caxy_end
|
||||
|
||||
caxy_tail: // Same calculation, but read in values to avoid trampling memory
|
||||
MOVUPS (SI)(AX*8), X2 // X_i = { imag(x[i]), real(x[i]) }
|
||||
MOVDDUP_X2_X3 // X_(i+1) = { real(x[i], real(x[i]) }
|
||||
SHUFPD $0x3, X2, X2 // X_i = { imag(x[i]), imag(x[i]) }
|
||||
MULPD X1, X2 // X_i = { real(a) * imag(x[i]), imag(a) * imag(x[i]) }
|
||||
MULPD X0, X3 // X_(i+1) = { imag(a) * real(x[i]), real(a) * real(x[i]) }
|
||||
|
||||
// X_(i+1) = {
|
||||
// imag(result[i]): imag(a)*real(x[i]) + real(a)*imag(x[i]),
|
||||
// real(result[i]): real(a)*real(x[i]) - imag(a)*imag(x[i])
|
||||
// }
|
||||
ADDSUBPD_X2_X3
|
||||
|
||||
// X_(i+1) = { imag(result[i]) + imag(y[i]), real(result[i]) + real(y[i]) }
|
||||
ADDPD (DX)(AX*8), X3
|
||||
MOVUPS X3, (DI)(AX*8) // y[i] = X_(i+1)
|
||||
ADDQ $2, AX // i += 2
|
||||
LOOP caxy_tail // } while --CX > 0
|
||||
|
||||
caxy_end:
|
||||
RET
|
||||
6
vendor/gonum.org/v1/gonum/internal/asm/c128/doc.go
generated
vendored
Normal file
6
vendor/gonum.org/v1/gonum/internal/asm/c128/doc.go
generated
vendored
Normal file
@@ -0,0 +1,6 @@
|
||||
// Copyright ©2017 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
// Package c128 provides complex128 vector primitives.
|
||||
package c128 // import "gonum.org/v1/gonum/internal/asm/c128"
|
||||
153
vendor/gonum.org/v1/gonum/internal/asm/c128/dotcinc_amd64.s
generated
vendored
Normal file
153
vendor/gonum.org/v1/gonum/internal/asm/c128/dotcinc_amd64.s
generated
vendored
Normal file
@@ -0,0 +1,153 @@
|
||||
// Copyright ©2016 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
//+build !noasm,!appengine,!safe
|
||||
|
||||
#include "textflag.h"
|
||||
|
||||
#define MOVDDUP_XPTR__X3 LONG $0x1E120FF2 // MOVDDUP (SI), X3
|
||||
#define MOVDDUP_XPTR_INCX__X5 LONG $0x120F42F2; WORD $0x062C // MOVDDUP (SI)(R8*1), X5
|
||||
#define MOVDDUP_XPTR_INCX_2__X7 LONG $0x120F42F2; WORD $0x463C // MOVDDUP (SI)(R8*2), X7
|
||||
#define MOVDDUP_XPTR_INCx3X__X9 LONG $0x120F46F2; WORD $0x0E0C // MOVDDUP (SI)(R9*1), X9
|
||||
|
||||
#define MOVDDUP_8_XPTR__X2 LONG $0x56120FF2; BYTE $0x08 // MOVDDUP 8(SI), X2
|
||||
#define MOVDDUP_8_XPTR_INCX__X4 LONG $0x120F42F2; WORD $0x0664; BYTE $0x08 // MOVDDUP 8(SI)(R8*1), X4
|
||||
#define MOVDDUP_8_XPTR_INCX_2__X6 LONG $0x120F42F2; WORD $0x4674; BYTE $0x08 // MOVDDUP 8(SI)(R8*2), X6
|
||||
#define MOVDDUP_8_XPTR_INCx3X__X8 LONG $0x120F46F2; WORD $0x0E44; BYTE $0x08 // MOVDDUP 8(SI)(R9*1), X8
|
||||
|
||||
#define ADDSUBPD_X2_X3 LONG $0xDAD00F66 // ADDSUBPD X2, X3
|
||||
#define ADDSUBPD_X4_X5 LONG $0xECD00F66 // ADDSUBPD X4, X5
|
||||
#define ADDSUBPD_X6_X7 LONG $0xFED00F66 // ADDSUBPD X6, X7
|
||||
#define ADDSUBPD_X8_X9 LONG $0xD00F4566; BYTE $0xC8 // ADDSUBPD X8, X9
|
||||
|
||||
#define X_PTR SI
|
||||
#define Y_PTR DI
|
||||
#define LEN CX
|
||||
#define TAIL BX
|
||||
#define SUM X0
|
||||
#define P_SUM X1
|
||||
#define INC_X R8
|
||||
#define INCx3_X R9
|
||||
#define INC_Y R10
|
||||
#define INCx3_Y R11
|
||||
#define NEG1 X15
|
||||
#define P_NEG1 X14
|
||||
|
||||
// func DotcInc(x, y []complex128, n, incX, incY, ix, iy uintptr) (sum complex128)
|
||||
TEXT ·DotcInc(SB), NOSPLIT, $0
|
||||
MOVQ x_base+0(FP), X_PTR // X_PTR = &x
|
||||
MOVQ y_base+24(FP), Y_PTR // Y_PTR = &y
|
||||
MOVQ n+48(FP), LEN // LEN = n
|
||||
PXOR SUM, SUM // SUM = 0
|
||||
CMPQ LEN, $0 // if LEN == 0 { return }
|
||||
JE dot_end
|
||||
PXOR P_SUM, P_SUM // P_SUM = 0
|
||||
MOVQ ix+72(FP), INC_X // INC_X = ix * sizeof(complex128)
|
||||
SHLQ $4, INC_X
|
||||
MOVQ iy+80(FP), INC_Y // INC_Y = iy * sizeof(complex128)
|
||||
SHLQ $4, INC_Y
|
||||
LEAQ (X_PTR)(INC_X*1), X_PTR // X_PTR = &(X_PTR[ix])
|
||||
LEAQ (Y_PTR)(INC_Y*1), Y_PTR // Y_PTR = &(Y_PTR[iy])
|
||||
MOVQ incX+56(FP), INC_X // INC_X = incX
|
||||
SHLQ $4, INC_X // INC_X *= sizeof(complex128)
|
||||
MOVQ incY+64(FP), INC_Y // INC_Y = incY
|
||||
SHLQ $4, INC_Y // INC_Y *= sizeof(complex128)
|
||||
MOVSD $(-1.0), NEG1
|
||||
SHUFPD $0, NEG1, NEG1 // { -1, -1 }
|
||||
MOVQ LEN, TAIL
|
||||
ANDQ $3, TAIL // TAIL = n % 4
|
||||
SHRQ $2, LEN // LEN = floor( n / 4 )
|
||||
JZ dot_tail // if n <= 4 { goto dot_tail }
|
||||
MOVAPS NEG1, P_NEG1 // Copy NEG1 to P_NEG1 for pipelining
|
||||
LEAQ (INC_X)(INC_X*2), INCx3_X // INCx3_X = 3 * incX * sizeof(complex128)
|
||||
LEAQ (INC_Y)(INC_Y*2), INCx3_Y // INCx3_Y = 3 * incY * sizeof(complex128)
|
||||
|
||||
dot_loop: // do {
|
||||
MOVDDUP_XPTR__X3 // X_(i+1) = { real(x[i], real(x[i]) }
|
||||
MOVDDUP_XPTR_INCX__X5
|
||||
MOVDDUP_XPTR_INCX_2__X7
|
||||
MOVDDUP_XPTR_INCx3X__X9
|
||||
|
||||
MOVDDUP_8_XPTR__X2 // X_i = { imag(x[i]), imag(x[i]) }
|
||||
MOVDDUP_8_XPTR_INCX__X4
|
||||
MOVDDUP_8_XPTR_INCX_2__X6
|
||||
MOVDDUP_8_XPTR_INCx3X__X8
|
||||
|
||||
// X_i = { -imag(x[i]), -imag(x[i]) }
|
||||
MULPD NEG1, X2
|
||||
MULPD P_NEG1, X4
|
||||
MULPD NEG1, X6
|
||||
MULPD P_NEG1, X8
|
||||
|
||||
// X_j = { imag(y[i]), real(y[i]) }
|
||||
MOVUPS (Y_PTR), X10
|
||||
MOVUPS (Y_PTR)(INC_Y*1), X11
|
||||
MOVUPS (Y_PTR)(INC_Y*2), X12
|
||||
MOVUPS (Y_PTR)(INCx3_Y*1), X13
|
||||
|
||||
// X_(i+1) = { imag(a) * real(x[i]), real(a) * real(x[i]) }
|
||||
MULPD X10, X3
|
||||
MULPD X11, X5
|
||||
MULPD X12, X7
|
||||
MULPD X13, X9
|
||||
|
||||
// X_j = { real(y[i]), imag(y[i]) }
|
||||
SHUFPD $0x1, X10, X10
|
||||
SHUFPD $0x1, X11, X11
|
||||
SHUFPD $0x1, X12, X12
|
||||
SHUFPD $0x1, X13, X13
|
||||
|
||||
// X_i = { real(a) * imag(x[i]), imag(a) * imag(x[i]) }
|
||||
MULPD X10, X2
|
||||
MULPD X11, X4
|
||||
MULPD X12, X6
|
||||
MULPD X13, X8
|
||||
|
||||
// X_(i+1) = {
|
||||
// imag(result[i]): imag(a)*real(x[i]) + real(a)*imag(x[i]),
|
||||
// real(result[i]): real(a)*real(x[i]) - imag(a)*imag(x[i])
|
||||
// }
|
||||
ADDSUBPD_X2_X3
|
||||
ADDSUBPD_X4_X5
|
||||
ADDSUBPD_X6_X7
|
||||
ADDSUBPD_X8_X9
|
||||
|
||||
// psum += result[i]
|
||||
ADDPD X3, SUM
|
||||
ADDPD X5, P_SUM
|
||||
ADDPD X7, SUM
|
||||
ADDPD X9, P_SUM
|
||||
|
||||
LEAQ (X_PTR)(INC_X*4), X_PTR // X_PTR = &(X_PTR[incX*4])
|
||||
LEAQ (Y_PTR)(INC_Y*4), Y_PTR // Y_PTR = &(Y_PTR[incY*4])
|
||||
|
||||
DECQ LEN
|
||||
JNZ dot_loop // } while --LEN > 0
|
||||
ADDPD P_SUM, SUM // sum += psum
|
||||
CMPQ TAIL, $0 // if TAIL == 0 { return }
|
||||
JE dot_end
|
||||
|
||||
dot_tail: // do {
|
||||
MOVDDUP_XPTR__X3 // X_(i+1) = { real(x[i], real(x[i]) }
|
||||
MOVDDUP_8_XPTR__X2 // X_i = { imag(x[i]), imag(x[i]) }
|
||||
MULPD NEG1, X2 // X_i = { -imag(x[i]) , -imag(x[i]) }
|
||||
MOVUPS (Y_PTR), X10 // X_j = { imag(y[i]) , real(y[i]) }
|
||||
MULPD X10, X3 // X_(i+1) = { imag(a) * real(x[i]), real(a) * real(x[i]) }
|
||||
SHUFPD $0x1, X10, X10 // X_j = { real(y[i]) , imag(y[i]) }
|
||||
MULPD X10, X2 // X_i = { real(a) * imag(x[i]), imag(a) * imag(x[i]) }
|
||||
|
||||
// X_(i+1) = {
|
||||
// imag(result[i]): imag(a)*real(x[i]) + real(a)*imag(x[i]),
|
||||
// real(result[i]): real(a)*real(x[i]) - imag(a)*imag(x[i])
|
||||
// }
|
||||
ADDSUBPD_X2_X3
|
||||
ADDPD X3, SUM // sum += result[i]
|
||||
ADDQ INC_X, X_PTR // X_PTR += incX
|
||||
ADDQ INC_Y, Y_PTR // Y_PTR += incY
|
||||
DECQ TAIL
|
||||
JNZ dot_tail // } while --TAIL > 0
|
||||
|
||||
dot_end:
|
||||
MOVUPS SUM, sum+88(FP)
|
||||
RET
|
||||
143
vendor/gonum.org/v1/gonum/internal/asm/c128/dotcunitary_amd64.s
generated
vendored
Normal file
143
vendor/gonum.org/v1/gonum/internal/asm/c128/dotcunitary_amd64.s
generated
vendored
Normal file
@@ -0,0 +1,143 @@
|
||||
// Copyright ©2016 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
//+build !noasm,!appengine,!safe
|
||||
|
||||
#include "textflag.h"
|
||||
|
||||
#define MOVDDUP_XPTR_IDX_8__X3 LONG $0x1C120FF2; BYTE $0xC6 // MOVDDUP (SI)(AX*8), X3
|
||||
#define MOVDDUP_16_XPTR_IDX_8__X5 LONG $0x6C120FF2; WORD $0x10C6 // MOVDDUP 16(SI)(AX*8), X5
|
||||
#define MOVDDUP_32_XPTR_IDX_8__X7 LONG $0x7C120FF2; WORD $0x20C6 // MOVDDUP 32(SI)(AX*8), X7
|
||||
#define MOVDDUP_48_XPTR_IDX_8__X9 LONG $0x120F44F2; WORD $0xC64C; BYTE $0x30 // MOVDDUP 48(SI)(AX*8), X9
|
||||
|
||||
#define MOVDDUP_XPTR_IIDX_8__X2 LONG $0x14120FF2; BYTE $0xD6 // MOVDDUP (SI)(DX*8), X2
|
||||
#define MOVDDUP_16_XPTR_IIDX_8__X4 LONG $0x64120FF2; WORD $0x10D6 // MOVDDUP 16(SI)(DX*8), X4
|
||||
#define MOVDDUP_32_XPTR_IIDX_8__X6 LONG $0x74120FF2; WORD $0x20D6 // MOVDDUP 32(SI)(DX*8), X6
|
||||
#define MOVDDUP_48_XPTR_IIDX_8__X8 LONG $0x120F44F2; WORD $0xD644; BYTE $0x30 // MOVDDUP 48(SI)(DX*8), X8
|
||||
|
||||
#define ADDSUBPD_X2_X3 LONG $0xDAD00F66 // ADDSUBPD X2, X3
|
||||
#define ADDSUBPD_X4_X5 LONG $0xECD00F66 // ADDSUBPD X4, X5
|
||||
#define ADDSUBPD_X6_X7 LONG $0xFED00F66 // ADDSUBPD X6, X7
|
||||
#define ADDSUBPD_X8_X9 LONG $0xD00F4566; BYTE $0xC8 // ADDSUBPD X8, X9
|
||||
|
||||
#define X_PTR SI
|
||||
#define Y_PTR DI
|
||||
#define LEN CX
|
||||
#define TAIL BX
|
||||
#define SUM X0
|
||||
#define P_SUM X1
|
||||
#define IDX AX
|
||||
#define I_IDX DX
|
||||
#define NEG1 X15
|
||||
#define P_NEG1 X14
|
||||
|
||||
// func DotcUnitary(x, y []complex128) (sum complex128)
|
||||
TEXT ·DotcUnitary(SB), NOSPLIT, $0
|
||||
MOVQ x_base+0(FP), X_PTR // X_PTR = &x
|
||||
MOVQ y_base+24(FP), Y_PTR // Y_PTR = &y
|
||||
MOVQ x_len+8(FP), LEN // LEN = min( len(x), len(y) )
|
||||
CMPQ y_len+32(FP), LEN
|
||||
CMOVQLE y_len+32(FP), LEN
|
||||
PXOR SUM, SUM // sum = 0
|
||||
CMPQ LEN, $0 // if LEN == 0 { return }
|
||||
JE dot_end
|
||||
XORPS P_SUM, P_SUM // psum = 0
|
||||
MOVSD $(-1.0), NEG1
|
||||
SHUFPD $0, NEG1, NEG1 // { -1, -1 }
|
||||
XORQ IDX, IDX // i := 0
|
||||
MOVQ $1, I_IDX // j := 1
|
||||
MOVQ LEN, TAIL
|
||||
ANDQ $3, TAIL // TAIL = floor( TAIL / 4 )
|
||||
SHRQ $2, LEN // LEN = TAIL % 4
|
||||
JZ dot_tail // if LEN == 0 { goto dot_tail }
|
||||
|
||||
MOVAPS NEG1, P_NEG1 // Copy NEG1 to P_NEG1 for pipelining
|
||||
|
||||
dot_loop: // do {
|
||||
MOVDDUP_XPTR_IDX_8__X3 // X_(i+1) = { real(x[i], real(x[i]) }
|
||||
MOVDDUP_16_XPTR_IDX_8__X5
|
||||
MOVDDUP_32_XPTR_IDX_8__X7
|
||||
MOVDDUP_48_XPTR_IDX_8__X9
|
||||
|
||||
MOVDDUP_XPTR_IIDX_8__X2 // X_i = { imag(x[i]), imag(x[i]) }
|
||||
MOVDDUP_16_XPTR_IIDX_8__X4
|
||||
MOVDDUP_32_XPTR_IIDX_8__X6
|
||||
MOVDDUP_48_XPTR_IIDX_8__X8
|
||||
|
||||
// X_i = { -imag(x[i]), -imag(x[i]) }
|
||||
MULPD NEG1, X2
|
||||
MULPD P_NEG1, X4
|
||||
MULPD NEG1, X6
|
||||
MULPD P_NEG1, X8
|
||||
|
||||
// X_j = { imag(y[i]), real(y[i]) }
|
||||
MOVUPS (Y_PTR)(IDX*8), X10
|
||||
MOVUPS 16(Y_PTR)(IDX*8), X11
|
||||
MOVUPS 32(Y_PTR)(IDX*8), X12
|
||||
MOVUPS 48(Y_PTR)(IDX*8), X13
|
||||
|
||||
// X_(i+1) = { imag(a) * real(x[i]), real(a) * real(x[i]) }
|
||||
MULPD X10, X3
|
||||
MULPD X11, X5
|
||||
MULPD X12, X7
|
||||
MULPD X13, X9
|
||||
|
||||
// X_j = { real(y[i]), imag(y[i]) }
|
||||
SHUFPD $0x1, X10, X10
|
||||
SHUFPD $0x1, X11, X11
|
||||
SHUFPD $0x1, X12, X12
|
||||
SHUFPD $0x1, X13, X13
|
||||
|
||||
// X_i = { real(a) * imag(x[i]), imag(a) * imag(x[i]) }
|
||||
MULPD X10, X2
|
||||
MULPD X11, X4
|
||||
MULPD X12, X6
|
||||
MULPD X13, X8
|
||||
|
||||
// X_(i+1) = {
|
||||
// imag(result[i]): imag(a)*real(x[i]) + real(a)*imag(x[i]),
|
||||
// real(result[i]): real(a)*real(x[i]) - imag(a)*imag(x[i])
|
||||
// }
|
||||
ADDSUBPD_X2_X3
|
||||
ADDSUBPD_X4_X5
|
||||
ADDSUBPD_X6_X7
|
||||
ADDSUBPD_X8_X9
|
||||
|
||||
// psum += result[i]
|
||||
ADDPD X3, SUM
|
||||
ADDPD X5, P_SUM
|
||||
ADDPD X7, SUM
|
||||
ADDPD X9, P_SUM
|
||||
|
||||
ADDQ $8, IDX // IDX += 8
|
||||
ADDQ $8, I_IDX // I_IDX += 8
|
||||
DECQ LEN
|
||||
JNZ dot_loop // } while --LEN > 0
|
||||
ADDPD P_SUM, SUM // sum += psum
|
||||
CMPQ TAIL, $0 // if TAIL == 0 { return }
|
||||
JE dot_end
|
||||
|
||||
dot_tail: // do {
|
||||
MOVDDUP_XPTR_IDX_8__X3 // X_(i+1) = { real(x[i]) , real(x[i]) }
|
||||
MOVDDUP_XPTR_IIDX_8__X2 // X_i = { imag(x[i]) , imag(x[i]) }
|
||||
MULPD NEG1, X2 // X_i = { -imag(x[i]) , -imag(x[i]) }
|
||||
MOVUPS (Y_PTR)(IDX*8), X10 // X_j = { imag(y[i]) , real(y[i]) }
|
||||
MULPD X10, X3 // X_(i+1) = { imag(a) * real(x[i]), real(a) * real(x[i]) }
|
||||
SHUFPD $0x1, X10, X10 // X_j = { real(y[i]) , imag(y[i]) }
|
||||
MULPD X10, X2 // X_i = { real(a) * imag(x[i]), imag(a) * imag(x[i]) }
|
||||
|
||||
// X_(i+1) = {
|
||||
// imag(result[i]): imag(a)*real(x[i]) + real(a)*imag(x[i]),
|
||||
// real(result[i]): real(a)*real(x[i]) - imag(a)*imag(x[i])
|
||||
// }
|
||||
ADDSUBPD_X2_X3
|
||||
ADDPD X3, SUM // SUM += result[i]
|
||||
ADDQ $2, IDX // IDX += 2
|
||||
ADDQ $2, I_IDX // I_IDX += 2
|
||||
DECQ TAIL
|
||||
JNZ dot_tail // } while --TAIL > 0
|
||||
|
||||
dot_end:
|
||||
MOVUPS SUM, sum+48(FP)
|
||||
RET
|
||||
141
vendor/gonum.org/v1/gonum/internal/asm/c128/dotuinc_amd64.s
generated
vendored
Normal file
141
vendor/gonum.org/v1/gonum/internal/asm/c128/dotuinc_amd64.s
generated
vendored
Normal file
@@ -0,0 +1,141 @@
|
||||
// Copyright ©2016 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
//+build !noasm,!appengine,!safe
|
||||
|
||||
#include "textflag.h"
|
||||
|
||||
#define MOVDDUP_XPTR__X3 LONG $0x1E120FF2 // MOVDDUP (SI), X3
|
||||
#define MOVDDUP_XPTR_INCX__X5 LONG $0x120F42F2; WORD $0x062C // MOVDDUP (SI)(R8*1), X5
|
||||
#define MOVDDUP_XPTR_INCX_2__X7 LONG $0x120F42F2; WORD $0x463C // MOVDDUP (SI)(R8*2), X7
|
||||
#define MOVDDUP_XPTR_INCx3X__X9 LONG $0x120F46F2; WORD $0x0E0C // MOVDDUP (SI)(R9*1), X9
|
||||
|
||||
#define MOVDDUP_8_XPTR__X2 LONG $0x56120FF2; BYTE $0x08 // MOVDDUP 8(SI), X2
|
||||
#define MOVDDUP_8_XPTR_INCX__X4 LONG $0x120F42F2; WORD $0x0664; BYTE $0x08 // MOVDDUP 8(SI)(R8*1), X4
|
||||
#define MOVDDUP_8_XPTR_INCX_2__X6 LONG $0x120F42F2; WORD $0x4674; BYTE $0x08 // MOVDDUP 8(SI)(R8*2), X6
|
||||
#define MOVDDUP_8_XPTR_INCx3X__X8 LONG $0x120F46F2; WORD $0x0E44; BYTE $0x08 // MOVDDUP 8(SI)(R9*1), X8
|
||||
|
||||
#define ADDSUBPD_X2_X3 LONG $0xDAD00F66 // ADDSUBPD X2, X3
|
||||
#define ADDSUBPD_X4_X5 LONG $0xECD00F66 // ADDSUBPD X4, X5
|
||||
#define ADDSUBPD_X6_X7 LONG $0xFED00F66 // ADDSUBPD X6, X7
|
||||
#define ADDSUBPD_X8_X9 LONG $0xD00F4566; BYTE $0xC8 // ADDSUBPD X8, X9
|
||||
|
||||
#define X_PTR SI
|
||||
#define Y_PTR DI
|
||||
#define LEN CX
|
||||
#define TAIL BX
|
||||
#define SUM X0
|
||||
#define P_SUM X1
|
||||
#define INC_X R8
|
||||
#define INCx3_X R9
|
||||
#define INC_Y R10
|
||||
#define INCx3_Y R11
|
||||
|
||||
// func DotuInc(x, y []complex128, n, incX, incY, ix, iy uintptr) (sum complex128)
|
||||
TEXT ·DotuInc(SB), NOSPLIT, $0
|
||||
MOVQ x_base+0(FP), X_PTR // X_PTR = &x
|
||||
MOVQ y_base+24(FP), Y_PTR // Y_PTR = &y
|
||||
MOVQ n+48(FP), LEN // LEN = n
|
||||
PXOR SUM, SUM // sum = 0
|
||||
CMPQ LEN, $0 // if LEN == 0 { return }
|
||||
JE dot_end
|
||||
MOVQ ix+72(FP), INC_X // INC_X = ix * sizeof(complex128)
|
||||
SHLQ $4, INC_X
|
||||
MOVQ iy+80(FP), INC_Y // INC_Y = iy * sizeof(complex128)
|
||||
SHLQ $4, INC_Y
|
||||
LEAQ (X_PTR)(INC_X*1), X_PTR // X_PTR = &(X_PTR[ix])
|
||||
LEAQ (Y_PTR)(INC_Y*1), Y_PTR // Y_PTR = &(Y_PTR[iy])
|
||||
MOVQ incX+56(FP), INC_X // INC_X = incX
|
||||
SHLQ $4, INC_X // INC_X *= sizeof(complex128)
|
||||
MOVQ incY+64(FP), INC_Y // INC_Y = incY
|
||||
SHLQ $4, INC_Y // INC_Y *= sizeof(complex128)
|
||||
MOVQ LEN, TAIL
|
||||
ANDQ $3, TAIL // LEN = LEN % 4
|
||||
SHRQ $2, LEN // LEN = floor( LEN / 4 )
|
||||
JZ dot_tail // if LEN <= 4 { goto dot_tail }
|
||||
PXOR P_SUM, P_SUM // psum = 0
|
||||
LEAQ (INC_X)(INC_X*2), INCx3_X // INCx3_X = 3 * incX * sizeof(complex128)
|
||||
LEAQ (INC_Y)(INC_Y*2), INCx3_Y // INCx3_Y = 3 * incY * sizeof(complex128)
|
||||
|
||||
dot_loop: // do {
|
||||
MOVDDUP_XPTR__X3 // X_(i+1) = { real(x[i], real(x[i]) }
|
||||
MOVDDUP_XPTR_INCX__X5
|
||||
MOVDDUP_XPTR_INCX_2__X7
|
||||
MOVDDUP_XPTR_INCx3X__X9
|
||||
|
||||
MOVDDUP_8_XPTR__X2 // X_i = { imag(x[i]), imag(x[i]) }
|
||||
MOVDDUP_8_XPTR_INCX__X4
|
||||
MOVDDUP_8_XPTR_INCX_2__X6
|
||||
MOVDDUP_8_XPTR_INCx3X__X8
|
||||
|
||||
// X_j = { imag(y[i]), real(y[i]) }
|
||||
MOVUPS (Y_PTR), X10
|
||||
MOVUPS (Y_PTR)(INC_Y*1), X11
|
||||
MOVUPS (Y_PTR)(INC_Y*2), X12
|
||||
MOVUPS (Y_PTR)(INCx3_Y*1), X13
|
||||
|
||||
// X_(i+1) = { imag(a) * real(x[i]), real(a) * real(x[i]) }
|
||||
MULPD X10, X3
|
||||
MULPD X11, X5
|
||||
MULPD X12, X7
|
||||
MULPD X13, X9
|
||||
|
||||
// X_j = { real(y[i]), imag(y[i]) }
|
||||
SHUFPD $0x1, X10, X10
|
||||
SHUFPD $0x1, X11, X11
|
||||
SHUFPD $0x1, X12, X12
|
||||
SHUFPD $0x1, X13, X13
|
||||
|
||||
// X_i = { real(a) * imag(x[i]), imag(a) * imag(x[i]) }
|
||||
MULPD X10, X2
|
||||
MULPD X11, X4
|
||||
MULPD X12, X6
|
||||
MULPD X13, X8
|
||||
|
||||
// X_(i+1) = {
|
||||
// imag(result[i]): imag(a)*real(x[i]) + real(a)*imag(x[i]),
|
||||
// real(result[i]): real(a)*real(x[i]) - imag(a)*imag(x[i])
|
||||
// }
|
||||
ADDSUBPD_X2_X3
|
||||
ADDSUBPD_X4_X5
|
||||
ADDSUBPD_X6_X7
|
||||
ADDSUBPD_X8_X9
|
||||
|
||||
// psum += result[i]
|
||||
ADDPD X3, SUM
|
||||
ADDPD X5, P_SUM
|
||||
ADDPD X7, SUM
|
||||
ADDPD X9, P_SUM
|
||||
|
||||
LEAQ (X_PTR)(INC_X*4), X_PTR // X_PTR = &(X_PTR[incX*4])
|
||||
LEAQ (Y_PTR)(INC_Y*4), Y_PTR // Y_PTR = &(Y_PTR[incY*4])
|
||||
|
||||
DECQ LEN
|
||||
JNZ dot_loop // } while --BX > 0
|
||||
ADDPD P_SUM, SUM // sum += psum
|
||||
CMPQ TAIL, $0 // if TAIL == 0 { return }
|
||||
JE dot_end
|
||||
|
||||
dot_tail: // do {
|
||||
MOVDDUP_XPTR__X3 // X_(i+1) = { real(x[i], real(x[i]) }
|
||||
MOVDDUP_8_XPTR__X2 // X_i = { imag(x[i]), imag(x[i]) }
|
||||
MOVUPS (Y_PTR), X10 // X_j = { imag(y[i]) , real(y[i]) }
|
||||
MULPD X10, X3 // X_(i+1) = { imag(a) * real(x[i]), real(a) * real(x[i]) }
|
||||
SHUFPD $0x1, X10, X10 // X_j = { real(y[i]) , imag(y[i]) }
|
||||
MULPD X10, X2 // X_i = { real(a) * imag(x[i]), imag(a) * imag(x[i]) }
|
||||
|
||||
// X_(i+1) = {
|
||||
// imag(result[i]): imag(a)*real(x[i]) + real(a)*imag(x[i]),
|
||||
// real(result[i]): real(a)*real(x[i]) - imag(a)*imag(x[i])
|
||||
// }
|
||||
ADDSUBPD_X2_X3
|
||||
ADDPD X3, SUM // sum += result[i]
|
||||
ADDQ INC_X, X_PTR // X_PTR += incX
|
||||
ADDQ INC_Y, Y_PTR // Y_PTR += incY
|
||||
DECQ TAIL // --TAIL
|
||||
JNZ dot_tail // } while TAIL > 0
|
||||
|
||||
dot_end:
|
||||
MOVUPS SUM, sum+88(FP)
|
||||
RET
|
||||
130
vendor/gonum.org/v1/gonum/internal/asm/c128/dotuunitary_amd64.s
generated
vendored
Normal file
130
vendor/gonum.org/v1/gonum/internal/asm/c128/dotuunitary_amd64.s
generated
vendored
Normal file
@@ -0,0 +1,130 @@
|
||||
// Copyright ©2016 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
//+build !noasm,!appengine,!safe
|
||||
|
||||
#include "textflag.h"
|
||||
|
||||
#define MOVDDUP_XPTR_IDX_8__X3 LONG $0x1C120FF2; BYTE $0xC6 // MOVDDUP (SI)(AX*8), X3
|
||||
#define MOVDDUP_16_XPTR_IDX_8__X5 LONG $0x6C120FF2; WORD $0x10C6 // MOVDDUP 16(SI)(AX*8), X5
|
||||
#define MOVDDUP_32_XPTR_IDX_8__X7 LONG $0x7C120FF2; WORD $0x20C6 // MOVDDUP 32(SI)(AX*8), X7
|
||||
#define MOVDDUP_48_XPTR_IDX_8__X9 LONG $0x120F44F2; WORD $0xC64C; BYTE $0x30 // MOVDDUP 48(SI)(AX*8), X9
|
||||
|
||||
#define MOVDDUP_XPTR_IIDX_8__X2 LONG $0x14120FF2; BYTE $0xD6 // MOVDDUP (SI)(DX*8), X2
|
||||
#define MOVDDUP_16_XPTR_IIDX_8__X4 LONG $0x64120FF2; WORD $0x10D6 // MOVDDUP 16(SI)(DX*8), X4
|
||||
#define MOVDDUP_32_XPTR_IIDX_8__X6 LONG $0x74120FF2; WORD $0x20D6 // MOVDDUP 32(SI)(DX*8), X6
|
||||
#define MOVDDUP_48_XPTR_IIDX_8__X8 LONG $0x120F44F2; WORD $0xD644; BYTE $0x30 // MOVDDUP 48(SI)(DX*8), X8
|
||||
|
||||
#define ADDSUBPD_X2_X3 LONG $0xDAD00F66 // ADDSUBPD X2, X3
|
||||
#define ADDSUBPD_X4_X5 LONG $0xECD00F66 // ADDSUBPD X4, X5
|
||||
#define ADDSUBPD_X6_X7 LONG $0xFED00F66 // ADDSUBPD X6, X7
|
||||
#define ADDSUBPD_X8_X9 LONG $0xD00F4566; BYTE $0xC8 // ADDSUBPD X8, X9
|
||||
|
||||
#define X_PTR SI
|
||||
#define Y_PTR DI
|
||||
#define LEN CX
|
||||
#define TAIL BX
|
||||
#define SUM X0
|
||||
#define P_SUM X1
|
||||
#define IDX AX
|
||||
#define I_IDX DX
|
||||
|
||||
// func DotuUnitary(x, y []complex128) (sum complex128)
|
||||
TEXT ·DotuUnitary(SB), NOSPLIT, $0
|
||||
MOVQ x_base+0(FP), X_PTR // X_PTR = &x
|
||||
MOVQ y_base+24(FP), Y_PTR // Y_PTR = &y
|
||||
MOVQ x_len+8(FP), LEN // LEN = min( len(x), len(y) )
|
||||
CMPQ y_len+32(FP), LEN
|
||||
CMOVQLE y_len+32(FP), LEN
|
||||
PXOR SUM, SUM // SUM = 0
|
||||
CMPQ LEN, $0 // if LEN == 0 { return }
|
||||
JE dot_end
|
||||
PXOR P_SUM, P_SUM // P_SUM = 0
|
||||
XORQ IDX, IDX // IDX = 0
|
||||
MOVQ $1, DX // j = 1
|
||||
MOVQ LEN, TAIL
|
||||
ANDQ $3, TAIL // TAIL = floor( LEN / 4 )
|
||||
SHRQ $2, LEN // LEN = LEN % 4
|
||||
JZ dot_tail // if LEN == 0 { goto dot_tail }
|
||||
|
||||
dot_loop: // do {
|
||||
MOVDDUP_XPTR_IDX_8__X3 // X_(i+1) = { real(x[i], real(x[i]) }
|
||||
MOVDDUP_16_XPTR_IDX_8__X5
|
||||
MOVDDUP_32_XPTR_IDX_8__X7
|
||||
MOVDDUP_48_XPTR_IDX_8__X9
|
||||
|
||||
MOVDDUP_XPTR_IIDX_8__X2 // X_i = { imag(x[i]), imag(x[i]) }
|
||||
MOVDDUP_16_XPTR_IIDX_8__X4
|
||||
MOVDDUP_32_XPTR_IIDX_8__X6
|
||||
MOVDDUP_48_XPTR_IIDX_8__X8
|
||||
|
||||
// X_j = { imag(y[i]), real(y[i]) }
|
||||
MOVUPS (Y_PTR)(IDX*8), X10
|
||||
MOVUPS 16(Y_PTR)(IDX*8), X11
|
||||
MOVUPS 32(Y_PTR)(IDX*8), X12
|
||||
MOVUPS 48(Y_PTR)(IDX*8), X13
|
||||
|
||||
// X_(i+1) = { imag(a) * real(x[i]), real(a) * real(x[i]) }
|
||||
MULPD X10, X3
|
||||
MULPD X11, X5
|
||||
MULPD X12, X7
|
||||
MULPD X13, X9
|
||||
|
||||
// X_j = { real(y[i]), imag(y[i]) }
|
||||
SHUFPD $0x1, X10, X10
|
||||
SHUFPD $0x1, X11, X11
|
||||
SHUFPD $0x1, X12, X12
|
||||
SHUFPD $0x1, X13, X13
|
||||
|
||||
// X_i = { real(a) * imag(x[i]), imag(a) * imag(x[i]) }
|
||||
MULPD X10, X2
|
||||
MULPD X11, X4
|
||||
MULPD X12, X6
|
||||
MULPD X13, X8
|
||||
|
||||
// X_(i+1) = {
|
||||
// imag(result[i]): imag(a)*real(x[i]) + real(a)*imag(x[i]),
|
||||
// real(result[i]): real(a)*real(x[i]) - imag(a)*imag(x[i])
|
||||
// }
|
||||
ADDSUBPD_X2_X3
|
||||
ADDSUBPD_X4_X5
|
||||
ADDSUBPD_X6_X7
|
||||
ADDSUBPD_X8_X9
|
||||
|
||||
// psum += result[i]
|
||||
ADDPD X3, SUM
|
||||
ADDPD X5, P_SUM
|
||||
ADDPD X7, SUM
|
||||
ADDPD X9, P_SUM
|
||||
|
||||
ADDQ $8, IDX // IDX += 8
|
||||
ADDQ $8, I_IDX // I_IDX += 8
|
||||
DECQ LEN
|
||||
JNZ dot_loop // } while --LEN > 0
|
||||
ADDPD P_SUM, SUM // SUM += P_SUM
|
||||
CMPQ TAIL, $0 // if TAIL == 0 { return }
|
||||
JE dot_end
|
||||
|
||||
dot_tail: // do {
|
||||
MOVDDUP_XPTR_IDX_8__X3 // X_(i+1) = { real(x[i] , real(x[i]) }
|
||||
MOVDDUP_XPTR_IIDX_8__X2 // X_i = { imag(x[i]) , imag(x[i]) }
|
||||
MOVUPS (Y_PTR)(IDX*8), X10 // X_j = { imag(y[i]) , real(y[i]) }
|
||||
MULPD X10, X3 // X_(i+1) = { imag(a) * real(x[i]), real(a) * real(x[i]) }
|
||||
SHUFPD $0x1, X10, X10 // X_j = { real(y[i]) , imag(y[i]) }
|
||||
MULPD X10, X2 // X_i = { real(a) * imag(x[i]), imag(a) * imag(x[i]) }
|
||||
|
||||
// X_(i+1) = {
|
||||
// imag(result[i]): imag(a)*real(x[i]) + real(a)*imag(x[i]),
|
||||
// real(result[i]): real(a)*real(x[i]) - imag(a)*imag(x[i])
|
||||
// }
|
||||
ADDSUBPD_X2_X3
|
||||
ADDPD X3, SUM // psum += result[i]
|
||||
ADDQ $2, IDX // IDX += 2
|
||||
ADDQ $2, I_IDX // I_IDX += 2
|
||||
DECQ TAIL // --TAIL
|
||||
JNZ dot_tail // } while TAIL > 0
|
||||
|
||||
dot_end:
|
||||
MOVUPS SUM, sum+48(FP)
|
||||
RET
|
||||
69
vendor/gonum.org/v1/gonum/internal/asm/c128/dscalinc_amd64.s
generated
vendored
Normal file
69
vendor/gonum.org/v1/gonum/internal/asm/c128/dscalinc_amd64.s
generated
vendored
Normal file
@@ -0,0 +1,69 @@
|
||||
// Copyright ©2017 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
//+build !noasm,!appengine,!safe
|
||||
|
||||
#include "textflag.h"
|
||||
|
||||
#define SRC SI
|
||||
#define DST SI
|
||||
#define LEN CX
|
||||
#define TAIL BX
|
||||
#define INC R9
|
||||
#define INC3 R10
|
||||
#define ALPHA X0
|
||||
#define ALPHA_2 X1
|
||||
|
||||
#define MOVDDUP_ALPHA LONG $0x44120FF2; WORD $0x0824 // MOVDDUP 8(SP), X0
|
||||
|
||||
// func DscalInc(alpha float64, x []complex128, n, inc uintptr)
|
||||
TEXT ·DscalInc(SB), NOSPLIT, $0
|
||||
MOVQ x_base+8(FP), SRC // SRC = &x
|
||||
MOVQ n+32(FP), LEN // LEN = n
|
||||
CMPQ LEN, $0 // if LEN == 0 { return }
|
||||
JE dscal_end
|
||||
|
||||
MOVDDUP_ALPHA // ALPHA = alpha
|
||||
MOVQ inc+40(FP), INC // INC = inc
|
||||
SHLQ $4, INC // INC = INC * sizeof(complex128)
|
||||
LEAQ (INC)(INC*2), INC3 // INC3 = 3 * INC
|
||||
MOVUPS ALPHA, ALPHA_2 // Copy ALPHA and ALPHA_2 for pipelining
|
||||
MOVQ LEN, TAIL // TAIL = LEN
|
||||
SHRQ $2, LEN // LEN = floor( n / 4 )
|
||||
JZ dscal_tail // if LEN == 0 { goto dscal_tail }
|
||||
|
||||
dscal_loop: // do {
|
||||
MOVUPS (SRC), X2 // X_i = x[i]
|
||||
MOVUPS (SRC)(INC*1), X3
|
||||
MOVUPS (SRC)(INC*2), X4
|
||||
MOVUPS (SRC)(INC3*1), X5
|
||||
|
||||
MULPD ALPHA, X2 // X_i *= ALPHA
|
||||
MULPD ALPHA_2, X3
|
||||
MULPD ALPHA, X4
|
||||
MULPD ALPHA_2, X5
|
||||
|
||||
MOVUPS X2, (DST) // x[i] = X_i
|
||||
MOVUPS X3, (DST)(INC*1)
|
||||
MOVUPS X4, (DST)(INC*2)
|
||||
MOVUPS X5, (DST)(INC3*1)
|
||||
|
||||
LEAQ (SRC)(INC*4), SRC // SRC += INC*4
|
||||
DECQ LEN
|
||||
JNZ dscal_loop // } while --LEN > 0
|
||||
|
||||
dscal_tail:
|
||||
ANDQ $3, TAIL // TAIL = TAIL % 4
|
||||
JE dscal_end // if TAIL == 0 { return }
|
||||
|
||||
dscal_tail_loop: // do {
|
||||
MOVUPS (SRC), X2 // X_i = x[i]
|
||||
MULPD ALPHA, X2 // X_i *= ALPHA
|
||||
MOVUPS X2, (DST) // x[i] = X_i
|
||||
ADDQ INC, SRC // SRC += INC
|
||||
DECQ TAIL
|
||||
JNZ dscal_tail_loop // } while --TAIL > 0
|
||||
|
||||
dscal_end:
|
||||
RET
|
||||
66
vendor/gonum.org/v1/gonum/internal/asm/c128/dscalunitary_amd64.s
generated
vendored
Normal file
66
vendor/gonum.org/v1/gonum/internal/asm/c128/dscalunitary_amd64.s
generated
vendored
Normal file
@@ -0,0 +1,66 @@
|
||||
// Copyright ©2017 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
//+build !noasm,!appengine,!safe
|
||||
|
||||
#include "textflag.h"
|
||||
|
||||
#define SRC SI
|
||||
#define DST SI
|
||||
#define LEN CX
|
||||
#define IDX AX
|
||||
#define TAIL BX
|
||||
#define ALPHA X0
|
||||
#define ALPHA_2 X1
|
||||
|
||||
#define MOVDDUP_ALPHA LONG $0x44120FF2; WORD $0x0824 // MOVDDUP 8(SP), X0
|
||||
|
||||
// func DscalUnitary(alpha float64, x []complex128)
|
||||
TEXT ·DscalUnitary(SB), NOSPLIT, $0
|
||||
MOVQ x_base+8(FP), SRC // SRC = &x
|
||||
MOVQ x_len+16(FP), LEN // LEN = len(x)
|
||||
CMPQ LEN, $0 // if LEN == 0 { return }
|
||||
JE dscal_end
|
||||
|
||||
MOVDDUP_ALPHA // ALPHA = alpha
|
||||
XORQ IDX, IDX // IDX = 0
|
||||
MOVUPS ALPHA, ALPHA_2 // Copy ALPHA to ALPHA_2 for pipelining
|
||||
MOVQ LEN, TAIL // TAIL = LEN
|
||||
SHRQ $2, LEN // LEN = floor( n / 4 )
|
||||
JZ dscal_tail // if LEN == 0 { goto dscal_tail }
|
||||
|
||||
dscal_loop: // do {
|
||||
MOVUPS (SRC)(IDX*8), X2 // X_i = x[i]
|
||||
MOVUPS 16(SRC)(IDX*8), X3
|
||||
MOVUPS 32(SRC)(IDX*8), X4
|
||||
MOVUPS 48(SRC)(IDX*8), X5
|
||||
|
||||
MULPD ALPHA, X2 // X_i *= ALPHA
|
||||
MULPD ALPHA_2, X3
|
||||
MULPD ALPHA, X4
|
||||
MULPD ALPHA_2, X5
|
||||
|
||||
MOVUPS X2, (DST)(IDX*8) // x[i] = X_i
|
||||
MOVUPS X3, 16(DST)(IDX*8)
|
||||
MOVUPS X4, 32(DST)(IDX*8)
|
||||
MOVUPS X5, 48(DST)(IDX*8)
|
||||
|
||||
ADDQ $8, IDX // IDX += 8
|
||||
DECQ LEN
|
||||
JNZ dscal_loop // } while --LEN > 0
|
||||
|
||||
dscal_tail:
|
||||
ANDQ $3, TAIL // TAIL = TAIL % 4
|
||||
JZ dscal_end // if TAIL == 0 { return }
|
||||
|
||||
dscal_tail_loop: // do {
|
||||
MOVUPS (SRC)(IDX*8), X2 // X_i = x[i]
|
||||
MULPD ALPHA, X2 // X_i *= ALPHA
|
||||
MOVUPS X2, (DST)(IDX*8) // x[i] = X_i
|
||||
ADDQ $2, IDX // IDX += 2
|
||||
DECQ TAIL
|
||||
JNZ dscal_tail_loop // } while --TAIL > 0
|
||||
|
||||
dscal_end:
|
||||
RET
|
||||
31
vendor/gonum.org/v1/gonum/internal/asm/c128/scal.go
generated
vendored
Normal file
31
vendor/gonum.org/v1/gonum/internal/asm/c128/scal.go
generated
vendored
Normal file
@@ -0,0 +1,31 @@
|
||||
// Copyright ©2016 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package c128
|
||||
|
||||
// ScalUnitaryTo is
|
||||
// for i, v := range x {
|
||||
// dst[i] = alpha * v
|
||||
// }
|
||||
func ScalUnitaryTo(dst []complex128, alpha complex128, x []complex128) {
|
||||
for i, v := range x {
|
||||
dst[i] = alpha * v
|
||||
}
|
||||
}
|
||||
|
||||
// ScalIncTo is
|
||||
// var idst, ix uintptr
|
||||
// for i := 0; i < int(n); i++ {
|
||||
// dst[idst] = alpha * x[ix]
|
||||
// ix += incX
|
||||
// idst += incDst
|
||||
// }
|
||||
func ScalIncTo(dst []complex128, incDst uintptr, alpha complex128, x []complex128, n, incX uintptr) {
|
||||
var idst, ix uintptr
|
||||
for i := 0; i < int(n); i++ {
|
||||
dst[idst] = alpha * x[ix]
|
||||
ix += incX
|
||||
idst += incDst
|
||||
}
|
||||
}
|
||||
116
vendor/gonum.org/v1/gonum/internal/asm/c128/scalUnitary_amd64.s
generated
vendored
Normal file
116
vendor/gonum.org/v1/gonum/internal/asm/c128/scalUnitary_amd64.s
generated
vendored
Normal file
@@ -0,0 +1,116 @@
|
||||
// Copyright ©2017 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
//+build !noasm,!appengine,!safe
|
||||
|
||||
#include "textflag.h"
|
||||
|
||||
#define SRC SI
|
||||
#define DST SI
|
||||
#define LEN CX
|
||||
#define IDX AX
|
||||
#define TAIL BX
|
||||
#define ALPHA X0
|
||||
#define ALPHA_C X1
|
||||
#define ALPHA2 X10
|
||||
#define ALPHA_C2 X11
|
||||
|
||||
#define MOVDDUP_X2_X3 LONG $0xDA120FF2 // MOVDDUP X2, X3
|
||||
#define MOVDDUP_X4_X5 LONG $0xEC120FF2 // MOVDDUP X4, X5
|
||||
#define MOVDDUP_X6_X7 LONG $0xFE120FF2 // MOVDDUP X6, X7
|
||||
#define MOVDDUP_X8_X9 LONG $0x120F45F2; BYTE $0xC8 // MOVDDUP X8, X9
|
||||
|
||||
#define ADDSUBPD_X2_X3 LONG $0xDAD00F66 // ADDSUBPD X2, X3
|
||||
#define ADDSUBPD_X4_X5 LONG $0xECD00F66 // ADDSUBPD X4, X5
|
||||
#define ADDSUBPD_X6_X7 LONG $0xFED00F66 // ADDSUBPD X6, X7
|
||||
#define ADDSUBPD_X8_X9 LONG $0xD00F4566; BYTE $0xC8 // ADDSUBPD X8, X9
|
||||
|
||||
// func ScalUnitary(alpha complex128, x []complex128)
|
||||
TEXT ·ScalUnitary(SB), NOSPLIT, $0
|
||||
MOVQ x_base+16(FP), SRC // SRC = &x
|
||||
MOVQ x_len+24(FP), LEN // LEN = len(x)
|
||||
CMPQ LEN, $0 // if LEN == 0 { return }
|
||||
JE scal_end
|
||||
|
||||
MOVUPS alpha+0(FP), ALPHA // ALPHA = { imag(alpha), real(alpha) }
|
||||
MOVAPS ALPHA, ALPHA_C
|
||||
SHUFPD $0x1, ALPHA_C, ALPHA_C // ALPHA_C = { real(alpha), imag(alpha) }
|
||||
|
||||
XORQ IDX, IDX // IDX = 0
|
||||
MOVAPS ALPHA, ALPHA2 // Copy ALPHA and ALPHA_C for pipelining
|
||||
MOVAPS ALPHA_C, ALPHA_C2
|
||||
MOVQ LEN, TAIL
|
||||
SHRQ $2, LEN // LEN = floor( n / 4 )
|
||||
JZ scal_tail // if BX == 0 { goto scal_tail }
|
||||
|
||||
scal_loop: // do {
|
||||
MOVUPS (SRC)(IDX*8), X2 // X_i = { imag(x[i]), real(x[i]) }
|
||||
MOVUPS 16(SRC)(IDX*8), X4
|
||||
MOVUPS 32(SRC)(IDX*8), X6
|
||||
MOVUPS 48(SRC)(IDX*8), X8
|
||||
|
||||
// X_(i+1) = { real(x[i], real(x[i]) }
|
||||
MOVDDUP_X2_X3
|
||||
MOVDDUP_X4_X5
|
||||
MOVDDUP_X6_X7
|
||||
MOVDDUP_X8_X9
|
||||
|
||||
// X_i = { imag(x[i]), imag(x[i]) }
|
||||
SHUFPD $0x3, X2, X2
|
||||
SHUFPD $0x3, X4, X4
|
||||
SHUFPD $0x3, X6, X6
|
||||
SHUFPD $0x3, X8, X8
|
||||
|
||||
// X_i = { real(ALPHA) * imag(x[i]), imag(ALPHA) * imag(x[i]) }
|
||||
// X_(i+1) = { imag(ALPHA) * real(x[i]), real(ALPHA) * real(x[i]) }
|
||||
MULPD ALPHA_C, X2
|
||||
MULPD ALPHA, X3
|
||||
MULPD ALPHA_C2, X4
|
||||
MULPD ALPHA2, X5
|
||||
MULPD ALPHA_C, X6
|
||||
MULPD ALPHA, X7
|
||||
MULPD ALPHA_C2, X8
|
||||
MULPD ALPHA2, X9
|
||||
|
||||
// X_(i+1) = {
|
||||
// imag(result[i]): imag(ALPHA)*real(x[i]) + real(ALPHA)*imag(x[i]),
|
||||
// real(result[i]): real(ALPHA)*real(x[i]) - imag(ALPHA)*imag(x[i])
|
||||
// }
|
||||
ADDSUBPD_X2_X3
|
||||
ADDSUBPD_X4_X5
|
||||
ADDSUBPD_X6_X7
|
||||
ADDSUBPD_X8_X9
|
||||
|
||||
MOVUPS X3, (DST)(IDX*8) // x[i] = X_(i+1)
|
||||
MOVUPS X5, 16(DST)(IDX*8)
|
||||
MOVUPS X7, 32(DST)(IDX*8)
|
||||
MOVUPS X9, 48(DST)(IDX*8)
|
||||
ADDQ $8, IDX // IDX += 8
|
||||
DECQ LEN
|
||||
JNZ scal_loop // } while --LEN > 0
|
||||
|
||||
scal_tail:
|
||||
ANDQ $3, TAIL // TAIL = TAIL % 4
|
||||
JZ scal_end // if TAIL == 0 { return }
|
||||
|
||||
scal_tail_loop: // do {
|
||||
MOVUPS (SRC)(IDX*8), X2 // X_i = { imag(x[i]), real(x[i]) }
|
||||
MOVDDUP_X2_X3 // X_(i+1) = { real(x[i], real(x[i]) }
|
||||
SHUFPD $0x3, X2, X2 // X_i = { imag(x[i]), imag(x[i]) }
|
||||
MULPD ALPHA_C, X2 // X_i = { real(ALPHA) * imag(x[i]), imag(ALPHA) * imag(x[i]) }
|
||||
MULPD ALPHA, X3 // X_(i+1) = { imag(ALPHA) * real(x[i]), real(ALPHA) * real(x[i]) }
|
||||
|
||||
// X_(i+1) = {
|
||||
// imag(result[i]): imag(ALPHA)*real(x[i]) + real(ALPHA)*imag(x[i]),
|
||||
// real(result[i]): real(ALPHA)*real(x[i]) - imag(ALPHA)*imag(x[i])
|
||||
// }
|
||||
ADDSUBPD_X2_X3
|
||||
|
||||
MOVUPS X3, (DST)(IDX*8) // x[i] = X_(i+1)
|
||||
ADDQ $2, IDX // IDX += 2
|
||||
DECQ TAIL
|
||||
JNZ scal_tail_loop // } while --LEN > 0
|
||||
|
||||
scal_end:
|
||||
RET
|
||||
121
vendor/gonum.org/v1/gonum/internal/asm/c128/scalinc_amd64.s
generated
vendored
Normal file
121
vendor/gonum.org/v1/gonum/internal/asm/c128/scalinc_amd64.s
generated
vendored
Normal file
@@ -0,0 +1,121 @@
|
||||
// Copyright ©2016 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
//+build !noasm,!appengine,!safe
|
||||
|
||||
#include "textflag.h"
|
||||
|
||||
#define SRC SI
|
||||
#define DST SI
|
||||
#define LEN CX
|
||||
#define TAIL BX
|
||||
#define INC R9
|
||||
#define INC3 R10
|
||||
#define ALPHA X0
|
||||
#define ALPHA_C X1
|
||||
#define ALPHA2 X10
|
||||
#define ALPHA_C2 X11
|
||||
|
||||
#define MOVDDUP_X2_X3 LONG $0xDA120FF2 // MOVDDUP X2, X3
|
||||
#define MOVDDUP_X4_X5 LONG $0xEC120FF2 // MOVDDUP X4, X5
|
||||
#define MOVDDUP_X6_X7 LONG $0xFE120FF2 // MOVDDUP X6, X7
|
||||
#define MOVDDUP_X8_X9 LONG $0x120F45F2; BYTE $0xC8 // MOVDDUP X8, X9
|
||||
|
||||
#define ADDSUBPD_X2_X3 LONG $0xDAD00F66 // ADDSUBPD X2, X3
|
||||
#define ADDSUBPD_X4_X5 LONG $0xECD00F66 // ADDSUBPD X4, X5
|
||||
#define ADDSUBPD_X6_X7 LONG $0xFED00F66 // ADDSUBPD X6, X7
|
||||
#define ADDSUBPD_X8_X9 LONG $0xD00F4566; BYTE $0xC8 // ADDSUBPD X8, X9
|
||||
|
||||
// func ScalInc(alpha complex128, x []complex128, n, inc uintptr)
|
||||
TEXT ·ScalInc(SB), NOSPLIT, $0
|
||||
MOVQ x_base+16(FP), SRC // SRC = &x
|
||||
MOVQ n+40(FP), LEN // LEN = len(x)
|
||||
CMPQ LEN, $0
|
||||
JE scal_end // if LEN == 0 { return }
|
||||
|
||||
MOVQ inc+48(FP), INC // INC = inc
|
||||
SHLQ $4, INC // INC = INC * sizeof(complex128)
|
||||
LEAQ (INC)(INC*2), INC3 // INC3 = 3 * INC
|
||||
|
||||
MOVUPS alpha+0(FP), ALPHA // ALPHA = { imag(alpha), real(alpha) }
|
||||
MOVAPS ALPHA, ALPHA_C
|
||||
SHUFPD $0x1, ALPHA_C, ALPHA_C // ALPHA_C = { real(alpha), imag(alpha) }
|
||||
|
||||
MOVAPS ALPHA, ALPHA2 // Copy ALPHA and ALPHA_C for pipelining
|
||||
MOVAPS ALPHA_C, ALPHA_C2
|
||||
MOVQ LEN, TAIL
|
||||
SHRQ $2, LEN // LEN = floor( n / 4 )
|
||||
JZ scal_tail // if BX == 0 { goto scal_tail }
|
||||
|
||||
scal_loop: // do {
|
||||
MOVUPS (SRC), X2 // X_i = { imag(x[i]), real(x[i]) }
|
||||
MOVUPS (SRC)(INC*1), X4
|
||||
MOVUPS (SRC)(INC*2), X6
|
||||
MOVUPS (SRC)(INC3*1), X8
|
||||
|
||||
// X_(i+1) = { real(x[i], real(x[i]) }
|
||||
MOVDDUP_X2_X3
|
||||
MOVDDUP_X4_X5
|
||||
MOVDDUP_X6_X7
|
||||
MOVDDUP_X8_X9
|
||||
|
||||
// X_i = { imag(x[i]), imag(x[i]) }
|
||||
SHUFPD $0x3, X2, X2
|
||||
SHUFPD $0x3, X4, X4
|
||||
SHUFPD $0x3, X6, X6
|
||||
SHUFPD $0x3, X8, X8
|
||||
|
||||
// X_i = { real(ALPHA) * imag(x[i]), imag(ALPHA) * imag(x[i]) }
|
||||
// X_(i+1) = { imag(ALPHA) * real(x[i]), real(ALPHA) * real(x[i]) }
|
||||
MULPD ALPHA_C, X2
|
||||
MULPD ALPHA, X3
|
||||
MULPD ALPHA_C2, X4
|
||||
MULPD ALPHA2, X5
|
||||
MULPD ALPHA_C, X6
|
||||
MULPD ALPHA, X7
|
||||
MULPD ALPHA_C2, X8
|
||||
MULPD ALPHA2, X9
|
||||
|
||||
// X_(i+1) = {
|
||||
// imag(result[i]): imag(ALPHA)*real(x[i]) + real(ALPHA)*imag(x[i]),
|
||||
// real(result[i]): real(ALPHA)*real(x[i]) - imag(ALPHA)*imag(x[i])
|
||||
// }
|
||||
ADDSUBPD_X2_X3
|
||||
ADDSUBPD_X4_X5
|
||||
ADDSUBPD_X6_X7
|
||||
ADDSUBPD_X8_X9
|
||||
|
||||
MOVUPS X3, (DST) // x[i] = X_(i+1)
|
||||
MOVUPS X5, (DST)(INC*1)
|
||||
MOVUPS X7, (DST)(INC*2)
|
||||
MOVUPS X9, (DST)(INC3*1)
|
||||
|
||||
LEAQ (SRC)(INC*4), SRC // SRC = &(SRC[inc*4])
|
||||
DECQ LEN
|
||||
JNZ scal_loop // } while --BX > 0
|
||||
|
||||
scal_tail:
|
||||
ANDQ $3, TAIL // TAIL = TAIL % 4
|
||||
JE scal_end // if TAIL == 0 { return }
|
||||
|
||||
scal_tail_loop: // do {
|
||||
MOVUPS (SRC), X2 // X_i = { imag(x[i]), real(x[i]) }
|
||||
MOVDDUP_X2_X3 // X_(i+1) = { real(x[i], real(x[i]) }
|
||||
SHUFPD $0x3, X2, X2 // X_i = { imag(x[i]), imag(x[i]) }
|
||||
MULPD ALPHA_C, X2 // X_i = { real(ALPHA) * imag(x[i]), imag(ALPHA) * imag(x[i]) }
|
||||
MULPD ALPHA, X3 // X_(i+1) = { imag(ALPHA) * real(x[i]), real(ALPHA) * real(x[i]) }
|
||||
|
||||
// X_(i+1) = {
|
||||
// imag(result[i]): imag(ALPHA)*real(x[i]) + real(ALPHA)*imag(x[i]),
|
||||
// real(result[i]): real(ALPHA)*real(x[i]) - imag(ALPHA)*imag(x[i])
|
||||
// }
|
||||
ADDSUBPD_X2_X3
|
||||
|
||||
MOVUPS X3, (DST) // x[i] = X_i
|
||||
ADDQ INC, SRC // SRC = &(SRC[incX])
|
||||
DECQ TAIL
|
||||
JNZ scal_tail_loop // } while --TAIL > 0
|
||||
|
||||
scal_end:
|
||||
RET
|
||||
96
vendor/gonum.org/v1/gonum/internal/asm/c128/stubs_amd64.go
generated
vendored
Normal file
96
vendor/gonum.org/v1/gonum/internal/asm/c128/stubs_amd64.go
generated
vendored
Normal file
@@ -0,0 +1,96 @@
|
||||
// Copyright ©2016 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
// +build !noasm,!appengine,!safe
|
||||
|
||||
package c128
|
||||
|
||||
// AxpyUnitary is
|
||||
// for i, v := range x {
|
||||
// y[i] += alpha * v
|
||||
// }
|
||||
func AxpyUnitary(alpha complex128, x, y []complex128)
|
||||
|
||||
// AxpyUnitaryTo is
|
||||
// for i, v := range x {
|
||||
// dst[i] = alpha*v + y[i]
|
||||
// }
|
||||
func AxpyUnitaryTo(dst []complex128, alpha complex128, x, y []complex128)
|
||||
|
||||
// AxpyInc is
|
||||
// for i := 0; i < int(n); i++ {
|
||||
// y[iy] += alpha * x[ix]
|
||||
// ix += incX
|
||||
// iy += incY
|
||||
// }
|
||||
func AxpyInc(alpha complex128, x, y []complex128, n, incX, incY, ix, iy uintptr)
|
||||
|
||||
// AxpyIncTo is
|
||||
// for i := 0; i < int(n); i++ {
|
||||
// dst[idst] = alpha*x[ix] + y[iy]
|
||||
// ix += incX
|
||||
// iy += incY
|
||||
// idst += incDst
|
||||
// }
|
||||
func AxpyIncTo(dst []complex128, incDst, idst uintptr, alpha complex128, x, y []complex128, n, incX, incY, ix, iy uintptr)
|
||||
|
||||
// DscalUnitary is
|
||||
// for i, v := range x {
|
||||
// x[i] = complex(real(v)*alpha, imag(v)*alpha)
|
||||
// }
|
||||
func DscalUnitary(alpha float64, x []complex128)
|
||||
|
||||
// DscalInc is
|
||||
// var ix uintptr
|
||||
// for i := 0; i < int(n); i++ {
|
||||
// x[ix] = complex(real(x[ix])*alpha, imag(x[ix])*alpha)
|
||||
// ix += inc
|
||||
// }
|
||||
func DscalInc(alpha float64, x []complex128, n, inc uintptr)
|
||||
|
||||
// ScalInc is
|
||||
// var ix uintptr
|
||||
// for i := 0; i < int(n); i++ {
|
||||
// x[ix] *= alpha
|
||||
// ix += incX
|
||||
// }
|
||||
func ScalInc(alpha complex128, x []complex128, n, inc uintptr)
|
||||
|
||||
// ScalUnitary is
|
||||
// for i := range x {
|
||||
// x[i] *= alpha
|
||||
// }
|
||||
func ScalUnitary(alpha complex128, x []complex128)
|
||||
|
||||
// DotcUnitary is
|
||||
// for i, v := range x {
|
||||
// sum += y[i] * cmplx.Conj(v)
|
||||
// }
|
||||
// return sum
|
||||
func DotcUnitary(x, y []complex128) (sum complex128)
|
||||
|
||||
// DotcInc is
|
||||
// for i := 0; i < int(n); i++ {
|
||||
// sum += y[iy] * cmplx.Conj(x[ix])
|
||||
// ix += incX
|
||||
// iy += incY
|
||||
// }
|
||||
// return sum
|
||||
func DotcInc(x, y []complex128, n, incX, incY, ix, iy uintptr) (sum complex128)
|
||||
|
||||
// DotuUnitary is
|
||||
// for i, v := range x {
|
||||
// sum += y[i] * v
|
||||
// }
|
||||
// return sum
|
||||
func DotuUnitary(x, y []complex128) (sum complex128)
|
||||
|
||||
// DotuInc is
|
||||
// for i := 0; i < int(n); i++ {
|
||||
// sum += y[iy] * x[ix]
|
||||
// ix += incX
|
||||
// iy += incY
|
||||
// }
|
||||
// return sum
|
||||
func DotuInc(x, y []complex128, n, incX, incY, ix, iy uintptr) (sum complex128)
|
||||
163
vendor/gonum.org/v1/gonum/internal/asm/c128/stubs_noasm.go
generated
vendored
Normal file
163
vendor/gonum.org/v1/gonum/internal/asm/c128/stubs_noasm.go
generated
vendored
Normal file
@@ -0,0 +1,163 @@
|
||||
// Copyright ©2016 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
// +build !amd64 noasm appengine safe
|
||||
|
||||
package c128
|
||||
|
||||
import "math/cmplx"
|
||||
|
||||
// AxpyUnitary is
|
||||
// for i, v := range x {
|
||||
// y[i] += alpha * v
|
||||
// }
|
||||
func AxpyUnitary(alpha complex128, x, y []complex128) {
|
||||
for i, v := range x {
|
||||
y[i] += alpha * v
|
||||
}
|
||||
}
|
||||
|
||||
// AxpyUnitaryTo is
|
||||
// for i, v := range x {
|
||||
// dst[i] = alpha*v + y[i]
|
||||
// }
|
||||
func AxpyUnitaryTo(dst []complex128, alpha complex128, x, y []complex128) {
|
||||
for i, v := range x {
|
||||
dst[i] = alpha*v + y[i]
|
||||
}
|
||||
}
|
||||
|
||||
// AxpyInc is
|
||||
// for i := 0; i < int(n); i++ {
|
||||
// y[iy] += alpha * x[ix]
|
||||
// ix += incX
|
||||
// iy += incY
|
||||
// }
|
||||
func AxpyInc(alpha complex128, x, y []complex128, n, incX, incY, ix, iy uintptr) {
|
||||
for i := 0; i < int(n); i++ {
|
||||
y[iy] += alpha * x[ix]
|
||||
ix += incX
|
||||
iy += incY
|
||||
}
|
||||
}
|
||||
|
||||
// AxpyIncTo is
|
||||
// for i := 0; i < int(n); i++ {
|
||||
// dst[idst] = alpha*x[ix] + y[iy]
|
||||
// ix += incX
|
||||
// iy += incY
|
||||
// idst += incDst
|
||||
// }
|
||||
func AxpyIncTo(dst []complex128, incDst, idst uintptr, alpha complex128, x, y []complex128, n, incX, incY, ix, iy uintptr) {
|
||||
for i := 0; i < int(n); i++ {
|
||||
dst[idst] = alpha*x[ix] + y[iy]
|
||||
ix += incX
|
||||
iy += incY
|
||||
idst += incDst
|
||||
}
|
||||
}
|
||||
|
||||
// DscalUnitary is
|
||||
// for i, v := range x {
|
||||
// x[i] = complex(real(v)*alpha, imag(v)*alpha)
|
||||
// }
|
||||
func DscalUnitary(alpha float64, x []complex128) {
|
||||
for i, v := range x {
|
||||
x[i] = complex(real(v)*alpha, imag(v)*alpha)
|
||||
}
|
||||
}
|
||||
|
||||
// DscalInc is
|
||||
// var ix uintptr
|
||||
// for i := 0; i < int(n); i++ {
|
||||
// x[ix] = complex(real(x[ix])*alpha, imag(x[ix])*alpha)
|
||||
// ix += inc
|
||||
// }
|
||||
func DscalInc(alpha float64, x []complex128, n, inc uintptr) {
|
||||
var ix uintptr
|
||||
for i := 0; i < int(n); i++ {
|
||||
x[ix] = complex(real(x[ix])*alpha, imag(x[ix])*alpha)
|
||||
ix += inc
|
||||
}
|
||||
}
|
||||
|
||||
// ScalInc is
|
||||
// var ix uintptr
|
||||
// for i := 0; i < int(n); i++ {
|
||||
// x[ix] *= alpha
|
||||
// ix += incX
|
||||
// }
|
||||
func ScalInc(alpha complex128, x []complex128, n, inc uintptr) {
|
||||
var ix uintptr
|
||||
for i := 0; i < int(n); i++ {
|
||||
x[ix] *= alpha
|
||||
ix += inc
|
||||
}
|
||||
}
|
||||
|
||||
// ScalUnitary is
|
||||
// for i := range x {
|
||||
// x[i] *= alpha
|
||||
// }
|
||||
func ScalUnitary(alpha complex128, x []complex128) {
|
||||
for i := range x {
|
||||
x[i] *= alpha
|
||||
}
|
||||
}
|
||||
|
||||
// DotcUnitary is
|
||||
// for i, v := range x {
|
||||
// sum += y[i] * cmplx.Conj(v)
|
||||
// }
|
||||
// return sum
|
||||
func DotcUnitary(x, y []complex128) (sum complex128) {
|
||||
for i, v := range x {
|
||||
sum += y[i] * cmplx.Conj(v)
|
||||
}
|
||||
return sum
|
||||
}
|
||||
|
||||
// DotcInc is
|
||||
// for i := 0; i < int(n); i++ {
|
||||
// sum += y[iy] * cmplx.Conj(x[ix])
|
||||
// ix += incX
|
||||
// iy += incY
|
||||
// }
|
||||
// return sum
|
||||
func DotcInc(x, y []complex128, n, incX, incY, ix, iy uintptr) (sum complex128) {
|
||||
for i := 0; i < int(n); i++ {
|
||||
sum += y[iy] * cmplx.Conj(x[ix])
|
||||
ix += incX
|
||||
iy += incY
|
||||
}
|
||||
return sum
|
||||
}
|
||||
|
||||
// DotuUnitary is
|
||||
// for i, v := range x {
|
||||
// sum += y[i] * v
|
||||
// }
|
||||
// return sum
|
||||
func DotuUnitary(x, y []complex128) (sum complex128) {
|
||||
for i, v := range x {
|
||||
sum += y[i] * v
|
||||
}
|
||||
return sum
|
||||
}
|
||||
|
||||
// DotuInc is
|
||||
// for i := 0; i < int(n); i++ {
|
||||
// sum += y[iy] * x[ix]
|
||||
// ix += incX
|
||||
// iy += incY
|
||||
// }
|
||||
// return sum
|
||||
func DotuInc(x, y []complex128, n, incX, incY, ix, iy uintptr) (sum complex128) {
|
||||
for i := 0; i < int(n); i++ {
|
||||
sum += y[iy] * x[ix]
|
||||
ix += incX
|
||||
iy += incY
|
||||
}
|
||||
return sum
|
||||
}
|
||||
151
vendor/gonum.org/v1/gonum/internal/asm/c64/axpyinc_amd64.s
generated
vendored
Normal file
151
vendor/gonum.org/v1/gonum/internal/asm/c64/axpyinc_amd64.s
generated
vendored
Normal file
@@ -0,0 +1,151 @@
|
||||
// Copyright ©2016 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
//+build !noasm,!appengine,!safe
|
||||
|
||||
#include "textflag.h"
|
||||
|
||||
// MOVSHDUP X3, X2
|
||||
#define MOVSHDUP_X3_X2 BYTE $0xF3; BYTE $0x0F; BYTE $0x16; BYTE $0xD3
|
||||
// MOVSLDUP X3, X3
|
||||
#define MOVSLDUP_X3_X3 BYTE $0xF3; BYTE $0x0F; BYTE $0x12; BYTE $0xDB
|
||||
// ADDSUBPS X2, X3
|
||||
#define ADDSUBPS_X2_X3 BYTE $0xF2; BYTE $0x0F; BYTE $0xD0; BYTE $0xDA
|
||||
|
||||
// MOVSHDUP X5, X4
|
||||
#define MOVSHDUP_X5_X4 BYTE $0xF3; BYTE $0x0F; BYTE $0x16; BYTE $0xE5
|
||||
// MOVSLDUP X5, X5
|
||||
#define MOVSLDUP_X5_X5 BYTE $0xF3; BYTE $0x0F; BYTE $0x12; BYTE $0xED
|
||||
// ADDSUBPS X4, X5
|
||||
#define ADDSUBPS_X4_X5 BYTE $0xF2; BYTE $0x0F; BYTE $0xD0; BYTE $0xEC
|
||||
|
||||
// MOVSHDUP X7, X6
|
||||
#define MOVSHDUP_X7_X6 BYTE $0xF3; BYTE $0x0F; BYTE $0x16; BYTE $0xF7
|
||||
// MOVSLDUP X7, X7
|
||||
#define MOVSLDUP_X7_X7 BYTE $0xF3; BYTE $0x0F; BYTE $0x12; BYTE $0xFF
|
||||
// ADDSUBPS X6, X7
|
||||
#define ADDSUBPS_X6_X7 BYTE $0xF2; BYTE $0x0F; BYTE $0xD0; BYTE $0xFE
|
||||
|
||||
// MOVSHDUP X9, X8
|
||||
#define MOVSHDUP_X9_X8 BYTE $0xF3; BYTE $0x45; BYTE $0x0F; BYTE $0x16; BYTE $0xC1
|
||||
// MOVSLDUP X9, X9
|
||||
#define MOVSLDUP_X9_X9 BYTE $0xF3; BYTE $0x45; BYTE $0x0F; BYTE $0x12; BYTE $0xC9
|
||||
// ADDSUBPS X8, X9
|
||||
#define ADDSUBPS_X8_X9 BYTE $0xF2; BYTE $0x45; BYTE $0x0F; BYTE $0xD0; BYTE $0xC8
|
||||
|
||||
// func AxpyInc(alpha complex64, x, y []complex64, n, incX, incY, ix, iy uintptr)
|
||||
TEXT ·AxpyInc(SB), NOSPLIT, $0
|
||||
MOVQ x_base+8(FP), SI // SI = &x
|
||||
MOVQ y_base+32(FP), DI // DI = &y
|
||||
MOVQ n+56(FP), CX // CX = n
|
||||
CMPQ CX, $0 // if n==0 { return }
|
||||
JE axpyi_end
|
||||
MOVQ ix+80(FP), R8 // R8 = ix
|
||||
MOVQ iy+88(FP), R9 // R9 = iy
|
||||
LEAQ (SI)(R8*8), SI // SI = &(x[ix])
|
||||
LEAQ (DI)(R9*8), DI // DI = &(y[iy])
|
||||
MOVQ DI, DX // DX = DI // Read/Write pointers
|
||||
MOVQ incX+64(FP), R8 // R8 = incX
|
||||
SHLQ $3, R8 // R8 *= sizeof(complex64)
|
||||
MOVQ incY+72(FP), R9 // R9 = incY
|
||||
SHLQ $3, R9 // R9 *= sizeof(complex64)
|
||||
MOVSD alpha+0(FP), X0 // X0 = { 0, 0, imag(a), real(a) }
|
||||
MOVAPS X0, X1
|
||||
SHUFPS $0x11, X1, X1 // X1 = { 0, 0, real(a), imag(a) }
|
||||
MOVAPS X0, X10 // Copy X0 and X1 for pipelining
|
||||
MOVAPS X1, X11
|
||||
MOVQ CX, BX
|
||||
ANDQ $3, CX // CX = n % 4
|
||||
SHRQ $2, BX // BX = floor( n / 4 )
|
||||
JZ axpyi_tail // if BX == 0 { goto axpyi_tail }
|
||||
|
||||
axpyi_loop: // do {
|
||||
MOVSD (SI), X3 // X_i = { imag(x[i+1]), real(x[i+1]) }
|
||||
MOVSD (SI)(R8*1), X5
|
||||
LEAQ (SI)(R8*2), SI // SI = &(SI[incX*2])
|
||||
MOVSD (SI), X7
|
||||
MOVSD (SI)(R8*1), X9
|
||||
|
||||
// X_(i-1) = { imag(x[i]), imag(x[i]) }
|
||||
MOVSHDUP_X3_X2
|
||||
MOVSHDUP_X5_X4
|
||||
MOVSHDUP_X7_X6
|
||||
MOVSHDUP_X9_X8
|
||||
|
||||
// X_i = { real(x[i]), real(x[i]) }
|
||||
MOVSLDUP_X3_X3
|
||||
MOVSLDUP_X5_X5
|
||||
MOVSLDUP_X7_X7
|
||||
MOVSLDUP_X9_X9
|
||||
|
||||
// X_(i-1) = { real(a) * imag(x[i]), imag(a) * imag(x[i]) }
|
||||
// X_i = { imag(a) * real(x[i]), real(a) * real(x[i]) }
|
||||
MULPS X1, X2
|
||||
MULPS X0, X3
|
||||
MULPS X11, X4
|
||||
MULPS X10, X5
|
||||
MULPS X1, X6
|
||||
MULPS X0, X7
|
||||
MULPS X11, X8
|
||||
MULPS X10, X9
|
||||
|
||||
// X_i = {
|
||||
// imag(result[i]): imag(a)*real(x[i]) + real(a)*imag(x[i]),
|
||||
// real(result[i]): real(a)*real(x[i]) - imag(a)*imag(x[i]),
|
||||
// }
|
||||
ADDSUBPS_X2_X3
|
||||
ADDSUBPS_X4_X5
|
||||
ADDSUBPS_X6_X7
|
||||
ADDSUBPS_X8_X9
|
||||
|
||||
// X_i = { imag(result[i]) + imag(y[i]), real(result[i]) + real(y[i]) }
|
||||
MOVSD (DX), X2
|
||||
MOVSD (DX)(R9*1), X4
|
||||
LEAQ (DX)(R9*2), DX // DX = &(DX[incY*2])
|
||||
MOVSD (DX), X6
|
||||
MOVSD (DX)(R9*1), X8
|
||||
ADDPS X2, X3
|
||||
ADDPS X4, X5
|
||||
ADDPS X6, X7
|
||||
ADDPS X8, X9
|
||||
|
||||
MOVSD X3, (DI) // y[i] = X_i
|
||||
MOVSD X5, (DI)(R9*1)
|
||||
LEAQ (DI)(R9*2), DI // DI = &(DI[incDst])
|
||||
MOVSD X7, (DI)
|
||||
MOVSD X9, (DI)(R9*1)
|
||||
LEAQ (SI)(R8*2), SI // SI = &(SI[incX*2])
|
||||
LEAQ (DX)(R9*2), DX // DX = &(DX[incY*2])
|
||||
LEAQ (DI)(R9*2), DI // DI = &(DI[incDst])
|
||||
DECQ BX
|
||||
JNZ axpyi_loop // } while --BX > 0
|
||||
CMPQ CX, $0 // if CX == 0 { return }
|
||||
JE axpyi_end
|
||||
|
||||
axpyi_tail: // do {
|
||||
MOVSD (SI), X3 // X_i = { imag(x[i+1]), real(x[i+1]) }
|
||||
MOVSHDUP_X3_X2 // X_(i-1) = { real(x[i]), real(x[i]) }
|
||||
MOVSLDUP_X3_X3 // X_i = { imag(x[i]), imag(x[i]) }
|
||||
|
||||
// X_i = { imag(a) * real(x[i]), real(a) * real(x[i]) }
|
||||
// X_(i-1) = { real(a) * imag(x[i]), imag(a) * imag(x[i]) }
|
||||
MULPS X1, X2
|
||||
MULPS X0, X3
|
||||
|
||||
// X_i = {
|
||||
// imag(result[i]): imag(a)*real(x[i]) + real(a)*imag(x[i]),
|
||||
// real(result[i]): real(a)*real(x[i]) - imag(a)*imag(x[i]),
|
||||
// }
|
||||
ADDSUBPS_X2_X3 // (ai*x1r+ar*x1i, ar*x1r-ai*x1i)
|
||||
|
||||
// X_i = { imag(result[i]) + imag(y[i]), real(result[i]) + real(y[i]) }
|
||||
MOVSD (DI), X4
|
||||
ADDPS X4, X3
|
||||
MOVSD X3, (DI) // y[i] = X_i
|
||||
ADDQ R8, SI // SI += incX
|
||||
ADDQ R9, DI // DI += incY
|
||||
LOOP axpyi_tail // } while --CX > 0
|
||||
|
||||
axpyi_end:
|
||||
RET
|
||||
156
vendor/gonum.org/v1/gonum/internal/asm/c64/axpyincto_amd64.s
generated
vendored
Normal file
156
vendor/gonum.org/v1/gonum/internal/asm/c64/axpyincto_amd64.s
generated
vendored
Normal file
@@ -0,0 +1,156 @@
|
||||
// Copyright ©2016 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
//+build !noasm,!appengine,!safe
|
||||
|
||||
#include "textflag.h"
|
||||
|
||||
// MOVSHDUP X3, X2
|
||||
#define MOVSHDUP_X3_X2 BYTE $0xF3; BYTE $0x0F; BYTE $0x16; BYTE $0xD3
|
||||
// MOVSLDUP X3, X3
|
||||
#define MOVSLDUP_X3_X3 BYTE $0xF3; BYTE $0x0F; BYTE $0x12; BYTE $0xDB
|
||||
// ADDSUBPS X2, X3
|
||||
#define ADDSUBPS_X2_X3 BYTE $0xF2; BYTE $0x0F; BYTE $0xD0; BYTE $0xDA
|
||||
|
||||
// MOVSHDUP X5, X4
|
||||
#define MOVSHDUP_X5_X4 BYTE $0xF3; BYTE $0x0F; BYTE $0x16; BYTE $0xE5
|
||||
// MOVSLDUP X5, X5
|
||||
#define MOVSLDUP_X5_X5 BYTE $0xF3; BYTE $0x0F; BYTE $0x12; BYTE $0xED
|
||||
// ADDSUBPS X4, X5
|
||||
#define ADDSUBPS_X4_X5 BYTE $0xF2; BYTE $0x0F; BYTE $0xD0; BYTE $0xEC
|
||||
|
||||
// MOVSHDUP X7, X6
|
||||
#define MOVSHDUP_X7_X6 BYTE $0xF3; BYTE $0x0F; BYTE $0x16; BYTE $0xF7
|
||||
// MOVSLDUP X7, X7
|
||||
#define MOVSLDUP_X7_X7 BYTE $0xF3; BYTE $0x0F; BYTE $0x12; BYTE $0xFF
|
||||
// ADDSUBPS X6, X7
|
||||
#define ADDSUBPS_X6_X7 BYTE $0xF2; BYTE $0x0F; BYTE $0xD0; BYTE $0xFE
|
||||
|
||||
// MOVSHDUP X9, X8
|
||||
#define MOVSHDUP_X9_X8 BYTE $0xF3; BYTE $0x45; BYTE $0x0F; BYTE $0x16; BYTE $0xC1
|
||||
// MOVSLDUP X9, X9
|
||||
#define MOVSLDUP_X9_X9 BYTE $0xF3; BYTE $0x45; BYTE $0x0F; BYTE $0x12; BYTE $0xC9
|
||||
// ADDSUBPS X8, X9
|
||||
#define ADDSUBPS_X8_X9 BYTE $0xF2; BYTE $0x45; BYTE $0x0F; BYTE $0xD0; BYTE $0xC8
|
||||
|
||||
// func AxpyIncTo(dst []complex64, incDst, idst uintptr, alpha complex64, x, y []complex64, n, incX, incY, ix, iy uintptr)
|
||||
TEXT ·AxpyIncTo(SB), NOSPLIT, $0
|
||||
MOVQ dst_base+0(FP), DI // DI = &dst
|
||||
MOVQ x_base+48(FP), SI // SI = &x
|
||||
MOVQ y_base+72(FP), DX // DX = &y
|
||||
MOVQ n+96(FP), CX // CX = n
|
||||
CMPQ CX, $0 // if n==0 { return }
|
||||
JE axpyi_end
|
||||
MOVQ ix+120(FP), R8 // Load the first index
|
||||
MOVQ iy+128(FP), R9
|
||||
MOVQ idst+32(FP), R10
|
||||
LEAQ (SI)(R8*8), SI // SI = &(x[ix])
|
||||
LEAQ (DX)(R9*8), DX // DX = &(y[iy])
|
||||
LEAQ (DI)(R10*8), DI // DI = &(dst[idst])
|
||||
MOVQ incX+104(FP), R8 // Incrementors*8 for easy iteration (ADDQ)
|
||||
SHLQ $3, R8
|
||||
MOVQ incY+112(FP), R9
|
||||
SHLQ $3, R9
|
||||
MOVQ incDst+24(FP), R10
|
||||
SHLQ $3, R10
|
||||
MOVSD alpha+40(FP), X0 // X0 = { 0, 0, imag(a), real(a) }
|
||||
MOVAPS X0, X1
|
||||
SHUFPS $0x11, X1, X1 // X1 = { 0, 0, real(a), imag(a) }
|
||||
MOVAPS X0, X10 // Copy X0 and X1 for pipelining
|
||||
MOVAPS X1, X11
|
||||
MOVQ CX, BX
|
||||
ANDQ $3, CX // CX = n % 4
|
||||
SHRQ $2, BX // BX = floor( n / 4 )
|
||||
JZ axpyi_tail // if BX == 0 { goto axpyi_tail }
|
||||
|
||||
axpyi_loop: // do {
|
||||
MOVSD (SI), X3 // X_i = { imag(x[i]), real(x[i]) }
|
||||
MOVSD (SI)(R8*1), X5
|
||||
LEAQ (SI)(R8*2), SI // SI = &(SI[incX*2])
|
||||
MOVSD (SI), X7
|
||||
MOVSD (SI)(R8*1), X9
|
||||
|
||||
// X_(i-1) = { imag(x[i]), imag(x[i]) }
|
||||
MOVSHDUP_X3_X2
|
||||
MOVSHDUP_X5_X4
|
||||
MOVSHDUP_X7_X6
|
||||
MOVSHDUP_X9_X8
|
||||
|
||||
// X_i = { real(x[i]), real(x[i]) }
|
||||
MOVSLDUP_X3_X3
|
||||
MOVSLDUP_X5_X5
|
||||
MOVSLDUP_X7_X7
|
||||
MOVSLDUP_X9_X9
|
||||
|
||||
// X_(i-1) = { real(a) * imag(x[i]), imag(a) * imag(x[i]) }
|
||||
// X_i = { imag(a) * real(x[i]), real(a) * real(x[i]) }
|
||||
MULPS X1, X2
|
||||
MULPS X0, X3
|
||||
MULPS X11, X4
|
||||
MULPS X10, X5
|
||||
MULPS X1, X6
|
||||
MULPS X0, X7
|
||||
MULPS X11, X8
|
||||
MULPS X10, X9
|
||||
|
||||
// X_i = {
|
||||
// imag(result[i]): imag(a)*real(x[i]) + real(a)*imag(x[i]),
|
||||
// real(result[i]): real(a)*real(x[i]) - imag(a)*imag(x[i]),
|
||||
// }
|
||||
ADDSUBPS_X2_X3
|
||||
ADDSUBPS_X4_X5
|
||||
ADDSUBPS_X6_X7
|
||||
ADDSUBPS_X8_X9
|
||||
|
||||
// X_i = { imag(result[i]) + imag(y[i]), real(result[i]) + real(y[i]) }
|
||||
MOVSD (DX), X2
|
||||
MOVSD (DX)(R9*1), X4
|
||||
LEAQ (DX)(R9*2), DX // DX = &(DX[incY*2])
|
||||
MOVSD (DX), X6
|
||||
MOVSD (DX)(R9*1), X8
|
||||
ADDPS X2, X3
|
||||
ADDPS X4, X5
|
||||
ADDPS X6, X7
|
||||
ADDPS X8, X9
|
||||
|
||||
MOVSD X3, (DI) // y[i] = X_i
|
||||
MOVSD X5, (DI)(R10*1)
|
||||
LEAQ (DI)(R10*2), DI // DI = &(DI[incDst])
|
||||
MOVSD X7, (DI)
|
||||
MOVSD X9, (DI)(R10*1)
|
||||
LEAQ (SI)(R8*2), SI // SI = &(SI[incX*2])
|
||||
LEAQ (DX)(R9*2), DX // DX = &(DX[incY*2])
|
||||
LEAQ (DI)(R10*2), DI // DI = &(DI[incDst])
|
||||
DECQ BX
|
||||
JNZ axpyi_loop // } while --BX > 0
|
||||
CMPQ CX, $0 // if CX == 0 { return }
|
||||
JE axpyi_end
|
||||
|
||||
axpyi_tail:
|
||||
MOVSD (SI), X3 // X_i = { imag(x[i]), real(x[i]) }
|
||||
MOVSHDUP_X3_X2 // X_(i-1) = { imag(x[i]), imag(x[i]) }
|
||||
MOVSLDUP_X3_X3 // X_i = { real(x[i]), real(x[i]) }
|
||||
|
||||
// X_i = { imag(a) * real(x[i]), real(a) * real(x[i]) }
|
||||
// X_(i-1) = { real(a) * imag(x[i]), imag(a) * imag(x[i]) }
|
||||
MULPS X1, X2
|
||||
MULPS X0, X3
|
||||
|
||||
// X_i = {
|
||||
// imag(result[i]): imag(a)*real(x[i]) + real(a)*imag(x[i]),
|
||||
// real(result[i]): real(a)*real(x[i]) - imag(a)*imag(x[i]),
|
||||
// }
|
||||
ADDSUBPS_X2_X3
|
||||
|
||||
// X_i = { imag(result[i]) + imag(y[i]), real(result[i]) + real(y[i]) }
|
||||
MOVSD (DX), X4
|
||||
ADDPS X4, X3
|
||||
MOVSD X3, (DI) // y[i] = X_i
|
||||
ADDQ R8, SI // SI += incX
|
||||
ADDQ R9, DX // DX += incY
|
||||
ADDQ R10, DI // DI += incDst
|
||||
LOOP axpyi_tail // } while --CX > 0
|
||||
|
||||
axpyi_end:
|
||||
RET
|
||||
160
vendor/gonum.org/v1/gonum/internal/asm/c64/axpyunitary_amd64.s
generated
vendored
Normal file
160
vendor/gonum.org/v1/gonum/internal/asm/c64/axpyunitary_amd64.s
generated
vendored
Normal file
@@ -0,0 +1,160 @@
|
||||
// Copyright ©2016 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
//+build !noasm,!appengine,!safe
|
||||
|
||||
#include "textflag.h"
|
||||
|
||||
// MOVSHDUP X3, X2
|
||||
#define MOVSHDUP_X3_X2 BYTE $0xF3; BYTE $0x0F; BYTE $0x16; BYTE $0xD3
|
||||
// MOVSLDUP X3, X3
|
||||
#define MOVSLDUP_X3_X3 BYTE $0xF3; BYTE $0x0F; BYTE $0x12; BYTE $0xDB
|
||||
// ADDSUBPS X2, X3
|
||||
#define ADDSUBPS_X2_X3 BYTE $0xF2; BYTE $0x0F; BYTE $0xD0; BYTE $0xDA
|
||||
|
||||
// MOVSHDUP X5, X4
|
||||
#define MOVSHDUP_X5_X4 BYTE $0xF3; BYTE $0x0F; BYTE $0x16; BYTE $0xE5
|
||||
// MOVSLDUP X5, X5
|
||||
#define MOVSLDUP_X5_X5 BYTE $0xF3; BYTE $0x0F; BYTE $0x12; BYTE $0xED
|
||||
// ADDSUBPS X4, X5
|
||||
#define ADDSUBPS_X4_X5 BYTE $0xF2; BYTE $0x0F; BYTE $0xD0; BYTE $0xEC
|
||||
|
||||
// MOVSHDUP X7, X6
|
||||
#define MOVSHDUP_X7_X6 BYTE $0xF3; BYTE $0x0F; BYTE $0x16; BYTE $0xF7
|
||||
// MOVSLDUP X7, X7
|
||||
#define MOVSLDUP_X7_X7 BYTE $0xF3; BYTE $0x0F; BYTE $0x12; BYTE $0xFF
|
||||
// ADDSUBPS X6, X7
|
||||
#define ADDSUBPS_X6_X7 BYTE $0xF2; BYTE $0x0F; BYTE $0xD0; BYTE $0xFE
|
||||
|
||||
// MOVSHDUP X9, X8
|
||||
#define MOVSHDUP_X9_X8 BYTE $0xF3; BYTE $0x45; BYTE $0x0F; BYTE $0x16; BYTE $0xC1
|
||||
// MOVSLDUP X9, X9
|
||||
#define MOVSLDUP_X9_X9 BYTE $0xF3; BYTE $0x45; BYTE $0x0F; BYTE $0x12; BYTE $0xC9
|
||||
// ADDSUBPS X8, X9
|
||||
#define ADDSUBPS_X8_X9 BYTE $0xF2; BYTE $0x45; BYTE $0x0F; BYTE $0xD0; BYTE $0xC8
|
||||
|
||||
// func AxpyUnitary(alpha complex64, x, y []complex64)
|
||||
TEXT ·AxpyUnitary(SB), NOSPLIT, $0
|
||||
MOVQ x_base+8(FP), SI // SI = &x
|
||||
MOVQ y_base+32(FP), DI // DI = &y
|
||||
MOVQ x_len+16(FP), CX // CX = min( len(x), len(y) )
|
||||
CMPQ y_len+40(FP), CX
|
||||
CMOVQLE y_len+40(FP), CX
|
||||
CMPQ CX, $0 // if CX == 0 { return }
|
||||
JE caxy_end
|
||||
PXOR X0, X0 // Clear work registers and cache-align loop
|
||||
PXOR X1, X1
|
||||
MOVSD alpha+0(FP), X0 // X0 = { 0, 0, imag(a), real(a) }
|
||||
SHUFPD $0, X0, X0 // X0 = { imag(a), real(a), imag(a), real(a) }
|
||||
MOVAPS X0, X1
|
||||
SHUFPS $0x11, X1, X1 // X1 = { real(a), imag(a), real(a), imag(a) }
|
||||
XORQ AX, AX // i = 0
|
||||
MOVQ DI, BX // Align on 16-byte boundary for ADDPS
|
||||
ANDQ $15, BX // BX = &y & 15
|
||||
JZ caxy_no_trim // if BX == 0 { goto caxy_no_trim }
|
||||
|
||||
// Trim first value in unaligned buffer
|
||||
XORPS X2, X2 // Clear work registers and cache-align loop
|
||||
XORPS X3, X3
|
||||
XORPS X4, X4
|
||||
MOVSD (SI)(AX*8), X3 // X3 = { imag(x[i]), real(x[i]) }
|
||||
MOVSHDUP_X3_X2 // X2 = { imag(x[i]), imag(x[i]) }
|
||||
MOVSLDUP_X3_X3 // X3 = { real(x[i]), real(x[i]) }
|
||||
MULPS X1, X2 // X2 = { real(a) * imag(x[i]), imag(a) * imag(x[i]) }
|
||||
MULPS X0, X3 // X3 = { imag(a) * real(x[i]), real(a) * real(x[i]) }
|
||||
|
||||
// X3 = { imag(a)*real(x[i]) + real(a)*imag(x[i]), real(a)*real(x[i]) - imag(a)*imag(x[i]) }
|
||||
ADDSUBPS_X2_X3
|
||||
MOVSD (DI)(AX*8), X4 // X3 += y[i]
|
||||
ADDPS X4, X3
|
||||
MOVSD X3, (DI)(AX*8) // y[i] = X3
|
||||
INCQ AX // i++
|
||||
DECQ CX // --CX
|
||||
JZ caxy_end // if CX == 0 { return }
|
||||
|
||||
caxy_no_trim:
|
||||
MOVAPS X0, X10 // Copy X0 and X1 for pipelineing
|
||||
MOVAPS X1, X11
|
||||
MOVQ CX, BX
|
||||
ANDQ $7, CX // CX = n % 8
|
||||
SHRQ $3, BX // BX = floor( n / 8 )
|
||||
JZ caxy_tail // if BX == 0 { goto caxy_tail }
|
||||
|
||||
caxy_loop: // do {
|
||||
// X_i = { imag(x[i]), real(x[i]), imag(x[i+1]), real(x[i+1]) }
|
||||
MOVUPS (SI)(AX*8), X3
|
||||
MOVUPS 16(SI)(AX*8), X5
|
||||
MOVUPS 32(SI)(AX*8), X7
|
||||
MOVUPS 48(SI)(AX*8), X9
|
||||
|
||||
// X_(i-1) = { imag(x[i]), imag(x[i]), imag(x[i]+1), imag(x[i]+1) }
|
||||
MOVSHDUP_X3_X2
|
||||
MOVSHDUP_X5_X4
|
||||
MOVSHDUP_X7_X6
|
||||
MOVSHDUP_X9_X8
|
||||
|
||||
// X_i = { real(x[i]), real(x[i]), real(x[i+1]), real(x[i+1]) }
|
||||
MOVSLDUP_X3_X3
|
||||
MOVSLDUP_X5_X5
|
||||
MOVSLDUP_X7_X7
|
||||
MOVSLDUP_X9_X9
|
||||
|
||||
// X_i = { imag(a) * real(x[i]), real(a) * real(x[i]),
|
||||
// imag(a) * real(x[i+1]), real(a) * real(x[i+1]) }
|
||||
// X_(i-1) = { real(a) * imag(x[i]), imag(a) * imag(x[i]),
|
||||
// real(a) * imag(x[i+1]), imag(a) * imag(x[i+1]) }
|
||||
MULPS X1, X2
|
||||
MULPS X0, X3
|
||||
MULPS X11, X4
|
||||
MULPS X10, X5
|
||||
MULPS X1, X6
|
||||
MULPS X0, X7
|
||||
MULPS X11, X8
|
||||
MULPS X10, X9
|
||||
|
||||
// X_i = {
|
||||
// imag(result[i]): imag(a)*real(x[i]) + real(a)*imag(x[i]),
|
||||
// real(result[i]): real(a)*real(x[i]) - imag(a)*imag(x[i]),
|
||||
// imag(result[i+1]): imag(a)*real(x[i+1]) + real(a)*imag(x[i+1]),
|
||||
// real(result[i+1]): real(a)*real(x[i+1]) - imag(a)*imag(x[i+1]),
|
||||
// }
|
||||
ADDSUBPS_X2_X3
|
||||
ADDSUBPS_X4_X5
|
||||
ADDSUBPS_X6_X7
|
||||
ADDSUBPS_X8_X9
|
||||
|
||||
// X_i = { imag(result[i]) + imag(y[i]), real(result[i]) + real(y[i]),
|
||||
// imag(result[i+1]) + imag(y[i+1]), real(result[i+1]) + real(y[i+1]) }
|
||||
ADDPS (DI)(AX*8), X3
|
||||
ADDPS 16(DI)(AX*8), X5
|
||||
ADDPS 32(DI)(AX*8), X7
|
||||
ADDPS 48(DI)(AX*8), X9
|
||||
MOVUPS X3, (DI)(AX*8) // y[i:i+1] = X_i
|
||||
MOVUPS X5, 16(DI)(AX*8)
|
||||
MOVUPS X7, 32(DI)(AX*8)
|
||||
MOVUPS X9, 48(DI)(AX*8)
|
||||
ADDQ $8, AX // i += 8
|
||||
DECQ BX // --BX
|
||||
JNZ caxy_loop // } while BX > 0
|
||||
CMPQ CX, $0 // if CX == 0 { return }
|
||||
JE caxy_end
|
||||
|
||||
caxy_tail: // do {
|
||||
MOVSD (SI)(AX*8), X3 // X3 = { imag(x[i]), real(x[i]) }
|
||||
MOVSHDUP_X3_X2 // X2 = { imag(x[i]), imag(x[i]) }
|
||||
MOVSLDUP_X3_X3 // X3 = { real(x[i]), real(x[i]) }
|
||||
MULPS X1, X2 // X2 = { real(a) * imag(x[i]), imag(a) * imag(x[i]) }
|
||||
MULPS X0, X3 // X3 = { imag(a) * real(x[i]), real(a) * real(x[i]) }
|
||||
|
||||
// X3 = { imag(a)*real(x[i]) + real(a)*imag(x[i]),
|
||||
// real(a)*real(x[i]) - imag(a)*imag(x[i]) }
|
||||
ADDSUBPS_X2_X3
|
||||
MOVSD (DI)(AX*8), X4 // X3 += y[i]
|
||||
ADDPS X4, X3
|
||||
MOVSD X3, (DI)(AX*8) // y[i] = X3
|
||||
INCQ AX // ++i
|
||||
LOOP caxy_tail // } while --CX > 0
|
||||
|
||||
caxy_end:
|
||||
RET
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user