Extreme Optimization™: Complexity made simple.

Math and Statistics
Libraries for .NET

  • Home
  • Features
    • Math Library
    • Vector and Matrix Library
    • Statistics Library
    • Performance
    • Usability
  • Documentation
    • Introduction
    • Math Library User's Guide
    • Vector and Matrix Library User's Guide
    • Data Analysis Library User's Guide
    • Statistics Library User's Guide
    • Reference
  • Resources
    • Downloads
    • QuickStart Samples
    • Sample Applications
    • Frequently Asked Questions
    • Technical Support
  • Blog
  • Order
  • Company
    • About us
    • Testimonials
    • Customers
    • Press Releases
    • Careers
    • Partners
    • Contact us
Introduction
Deployment Guide
Configuration
Using Parallelism
Expand Mathematics Library User's GuideMathematics Library User's Guide
Expand Vector and Matrix Library User's GuideVector and Matrix Library User's Guide
Expand Data Analysis Library User's GuideData Analysis Library User's Guide
Expand Statistics Library User's GuideStatistics Library User's Guide
Expand Data Access Library User's GuideData Access Library User's Guide
Expand ReferenceReference
  • Extreme Optimization
    • Features
    • Solutions
    • Documentation
    • QuickStart Samples
    • Sample Applications
    • Downloads
    • Technical Support
    • Download trial
    • How to buy
    • Blog
    • Company
    • Resources
  • Documentation
    • Introduction
    • Deployment Guide
    • Configuration
    • Using Parallelism
    • Mathematics Library User's Guide
    • Vector and Matrix Library User's Guide
    • Data Analysis Library User's Guide
    • Statistics Library User's Guide
    • Data Access Library User's Guide
    • Reference
  • Reference
    • Extreme
    • Extreme.Collections
    • Extreme.Data
    • Extreme.Data.Json
    • Extreme.Data.Matlab
    • Extreme.Data.R
    • Extreme.Data.Stata
    • Extreme.Data.Text
    • Extreme.DataAnalysis
    • Extreme.DataAnalysis.Linq
    • Extreme.Mathematics
    • Extreme.Mathematics.Algorithms
    • Extreme.Mathematics.Calculus
    • Extreme.Mathematics.Calculus.OrdinaryDifferentialEquations
    • Extreme.Mathematics.Curves
    • Extreme.Mathematics.Curves.Nonlinear
    • Extreme.Mathematics.Distributed
    • Extreme.Mathematics.Distributed.Cuda
    • Extreme.Mathematics.EquationSolvers
    • Extreme.Mathematics.FSharp
    • Extreme.Mathematics.Generic
    • Extreme.Mathematics.Generic.LinearAlgebra
    • Extreme.Mathematics.Generic.LinearAlgebra.Implementation
    • Extreme.Mathematics.Generic.LinearAlgebra.Providers
    • Extreme.Mathematics.Generic.SignalProcessing
    • Extreme.Mathematics.Implementation
    • Extreme.Mathematics.LinearAlgebra
    • Extreme.Mathematics.LinearAlgebra.Complex
    • Extreme.Mathematics.LinearAlgebra.Complex.Decompositions
    • Extreme.Mathematics.LinearAlgebra.Implementation
    • Extreme.Mathematics.LinearAlgebra.IO
    • Extreme.Mathematics.LinearAlgebra.IterativeSolvers
    • Extreme.Mathematics.LinearAlgebra.IterativeSolvers.Preconditioners
    • Extreme.Mathematics.LinearAlgebra.Providers
    • Extreme.Mathematics.LinearAlgebra.Sparse
    • Extreme.Mathematics.Optimization
    • Extreme.Mathematics.Optimization.Genetic
    • Extreme.Mathematics.Optimization.LineSearches
    • Extreme.Mathematics.Random
    • Extreme.Mathematics.SignalProcessing
    • Extreme.Numerics.FSharp
    • Extreme.Statistics
    • Extreme.Statistics.Distributions
    • Extreme.Statistics.IO
    • Extreme.Statistics.Linq
    • Extreme.Statistics.Multivariate
    • Extreme.Statistics.Random
    • Extreme.Statistics.Tests
    • Extreme.Statistics.TimeSeriesAnalysis
  • Extreme.Mathematics.Generic.LinearAlgebra.Implementation
    • GenericBlas(T) Class
    • GenericLapack(T) Class
    • GenericSparseLinearAlgebraOperations(T) Class
    • ManagedArrayFunctions(T) Class
  • GenericBlas(T) Class
    • GenericBlas(T) Constructor
    • Properties
    • Methods
  • Methods
    • AbsoluteMaxIndex Method Overloads
    • ApplyModifiedGivensRotation Method
    • BandHermitianMultiplyAndAddInPlace Method
    • BandMultiplyAndAddInPlace Method Overloads
    • BandSymmetricMultiplyAndAddInPlace Method
    • BandTriangularMultiplyInPlace Method Overloads
    • BandTriangularSolveInPlace Method Overloads
    • ConjugateDotProduct Method
    • ConjugateRankUpdate Method
    • Copy Method Overloads
    • CreateGivensRotation Method Overloads
    • CreateModifiedGivensRotation Method
    • Dcabs1 Method
    • DotProduct Method Overloads
    • FullMatrixNorm Method Overloads
    • HermitianMatrixNorm Method
    • HermitianMultiplyAndAddInPlace Method Overloads
    • HermitianRankUpdate Method Overloads
    • MultiplyAndAddInPlace Method Overloads
    • MultiplyInPlace Method Overloads
    • OneNorm Method
    • PackedHermitianMultiplyAndAddInPlace Method
    • PackedHermitianRankUpdate Method Overloads
    • PackedSymmetricMultiplyAndAddInPlace Method
    • PackedSymmetricRankUpdate Method Overloads
    • PackedTriangularMultiplyInPlace Method Overloads
    • PackedTriangularSolveInPlace Method Overloads
    • RankUpdate Method Overloads
    • RealOneNorm Method
    • Rotate Method Overloads
    • Swap Method Overloads
    • SymmetricMatrixNorm Method Overloads
    • SymmetricMultiplyAndAddInPlace Method Overloads
    • SymmetricRankUpdate Method Overloads
    • TriangularMatrixNorm Method Overloads
    • TriangularMultiplyInPlace Method Overloads
    • TriangularSolveInPlace Method Overloads
    • TwoNorm Method Overloads
  • MultiplyAndAddInPlace Method Overloads
    • MultiplyAndAddInPlace Method (Int32, Complex(T), ArraySlice(Complex(T)), ArraySlice(Complex(T)))
    • MultiplyAndAddInPlace Method (Int32, T, ArraySlice(T), ArraySlice(T))
    • MultiplyAndAddInPlace Method (TransposeOperation, Int32, Int32, Complex(T), Array2D(Complex(T)), ArraySlice(Complex(T)), Complex(T), ArraySlice(Complex(T)))
    • MultiplyAndAddInPlace Method (TransposeOperation, Int32, Int32, T, Array2D(T), ArraySlice(T), T, ArraySlice(T))
    • MultiplyAndAddInPlace Method (TransposeOperation, TransposeOperation, Int32, Int32, Int32, Complex(T), Array2D(Complex(T)), Array2D(Complex(T)), Complex(T), Array2D(Complex(T)))
    • MultiplyAndAddInPlace Method (TransposeOperation, TransposeOperation, Int32, Int32, Int32, T, Array2D(T), Array2D(T), T, Array2D(T))
  • MultiplyAndAddInPlace Method (TransposeOperation, Int32, Int32, T, Array2D(T), ArraySlice(T), T, ArraySlice(T))
GenericBlasTMultiplyAndAddInPlace Method (TransposeOperation, Int32, Int32, T, Array2DT, ArraySliceT, T, ArraySliceT)Extreme Optimization Numerical Libraries for .NET Professional

Performs one of the matrix-vector operations y := alpha*A*x + beta*y, or y := alpha*AT*x + beta*y, where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.

Namespace: Extreme.Mathematics.Generic.LinearAlgebra.Implementation
Assembly: Extreme.Numerics.Net40 (in Extreme.Numerics.Net40.dll) Version: 6.0.16073.0 (6.0.16312.0)
Syntax

C#
VB
C++
F#
Copy
public override void MultiplyAndAddInPlace(
	TransposeOperation trans,
	int m,
	int n,
	T alpha,
	Array2D<T> a,
	ArraySlice<T> x,
	T beta,
	ArraySlice<T> y
)
Public Overrides Sub MultiplyAndAddInPlace ( 
	trans As TransposeOperation,
	m As Integer,
	n As Integer,
	alpha As T,
	a As Array2D(Of T),
	x As ArraySlice(Of T),
	beta As T,
	y As ArraySlice(Of T)
)
public:
virtual void MultiplyAndAddInPlace(
	TransposeOperation trans, 
	int m, 
	int n, 
	T alpha, 
	Array2D<T> a, 
	ArraySlice<T> x, 
	T beta, 
	ArraySlice<T> y
) override
abstract MultiplyAndAddInPlace : 
        trans : TransposeOperation * 
        m : int * 
        n : int * 
        alpha : 'T * 
        a : Array2D<'T> * 
        x : ArraySlice<'T> * 
        beta : 'T * 
        y : ArraySlice<'T> -> unit 
override MultiplyAndAddInPlace : 
        trans : TransposeOperation * 
        m : int * 
        n : int * 
        alpha : 'T * 
        a : Array2D<'T> * 
        x : ArraySlice<'T> * 
        beta : 'T * 
        y : ArraySlice<'T> -> unit 

Parameters

trans
Type: Extreme.MathematicsTransposeOperation
             On entry, TRANS specifies the operation to be performed as
             follows:
                TRANS = 'N' or 'n'   y := alpha*A*x + beta*y.
                TRANS = 'T' or 't'   y := alpha*AT*x + beta*y.
                TRANS = 'C' or 'c'   y := alpha*AT*x + beta*y.
            
m
Type: SystemInt32
             On entry, M specifies the number of rows of the matrix A.
             M must be at least zero.
            
n
Type: SystemInt32
             On entry, N specifies the number of columns of the matrix A.
             N must be at least zero.
            
alpha
Type: T
            ALPHA is DOUBLE PRECISION.
             On entry, ALPHA specifies the scalar alpha.
            
a
Type: Extreme.CollectionsArray2DT
            A is DOUBLE PRECISION array of DIMENSION ( LDA, n ).
             Before entry, the leading m by n part of the array A must
             contain the matrix of coefficients.
            
             On entry, LDA specifies the first dimension of A as declared
             in the calling (sub) program. LDA must be at least
             max( 1, m ).
            
x
Type: Extreme.CollectionsArraySliceT
            X is DOUBLE PRECISION array of DIMENSION at least
             ( 1 + ( n - 1 )*abs( INCX ) ) when TRANS = 'N' or 'n'
             and at least
             ( 1 + ( m - 1 )*abs( INCX ) ) otherwise.
             Before entry, the incremented array X must contain the
             vector x.
            
             On entry, INCX specifies the increment for the elements of
             X. INCX must not be zero.
            
beta
Type: T
            BETA is DOUBLE PRECISION.
             On entry, BETA specifies the scalar beta. When BETA is
             supplied as zero then Y need not be set on input.
            
y
Type: Extreme.CollectionsArraySliceT
            Y is DOUBLE PRECISION array of DIMENSION at least
             ( 1 + ( m - 1 )*abs( INCY ) ) when TRANS = 'N' or 'n'
             and at least
             ( 1 + ( n - 1 )*abs( INCY ) ) otherwise.
             Before entry with BETA non-zero, the incremented array Y
             must contain the vector y. On exit, Y is overwritten by the
             updated vector y.
            
             On entry, INCY specifies the increment for the elements of
             Y. INCY must not be zero.
            

Implements

ILinearAlgebraOperationsTMultiplyAndAddInPlace(TransposeOperation, Int32, Int32, T, Array2DT, ArraySliceT, T, ArraySliceT)
Remarks

Further Details:

            Level 2 LinearAlgebra routine.
            The vector and matrix arguments are not referenced when N = 0, or M = 0
            -- Written on 22-October-1986.
               Jack Dongarra, Argonne National Lab.
               Jeremy Du Croz, Nag Central Office.
               Sven Hammarling, Nag Central Office.
               Richard Hanson, Sandia National Labs.
            

Authors: Univ. of Tennessee, Univ. of California Berkeley, Univ. of Colorado Denver, NAG Ltd.

Date: November 2011

Version Information

Numerical Libraries

Supported in: 5.x
See Also

Reference

GenericBlasT Class
MultiplyAndAddInPlace Overload
Extreme.Mathematics.Generic.LinearAlgebra.Implementation Namespace

Copyright (c) 2004-2016 ExoAnalytics Inc.

Send comments on this topic to support@extremeoptimization.com

Copyright © 2004-2018, Extreme Optimization. All rights reserved.
Extreme Optimization, Complexity made simple, M#, and M Sharp are trademarks of ExoAnalytics Inc.
Microsoft, Visual C#, Visual Basic, Visual Studio, Visual Studio.NET, and the Optimized for Visual Studio logo
are registered trademarks of Microsoft Corporation.