@startuml
interface "ColumnarData" {
    size: Int
}
interface "XYColumnarData" {
    x: Buffer
	y: Buffer
}
interface "XYErrorColumnarData" {
    yErr: Buffer
}
interface "XYZColumnarData" {
    z: Buffer
}
interface "Domain" {
    dimension: Int
}
interface "DoubleDomain" {
    
}
class "HyperSquareDomain" {
    lower: Buffer
	upper: Buffer
}
class "UnconstrainedDomain" {
    dimension: Int
}
class "UnivariateDomain" {
    range: ClosedFloatingPointRange
}
interface "DifferentiableExpression" {
    
}
interface "SpecialDifferentiableExpression" {
    
}
abstract "FirstDerivativeExpression" {
    
}
interface "AutoDiffProcessor" {
    
}
interface "Expression" {
    
}
interface "ExpressionAlgebra" {
    
}
abstract "FunctionalExpressionAlgebra" {
    algebra: A
}
class "FunctionalExpressionGroup" {
    algebra: A
}
class "FunctionalExpressionRing" {
    algebra: A
}
class "FunctionalExpressionField" {
    algebra: A
}
class "FunctionalExpressionExtendedField" {
    algebra: A
}
interface "MST" {
    
}
class "Numeric"  {
    value: Number
}
class "Unary"  {
    operation: String
	value: MST
}
class "Binary"  {
    operation: String
	left: MST
	right: MST
}
class "InnerAlgebra" {
    algebra: Algebra
	arguments: Map
}
class "MstNumericAlgebra"  {
   number()
	bindSymbolOrNull()
	bindSymbol()
	unaryOperationFunction()
	binaryOperationFunction()
}
class "MstGroup"  {
   zero: MST.Numericnumber()
	bindSymbolOrNull()
	add()
	unaryPlus()
	unaryMinus()
	minus()
	scale()
	binaryOperationFunction()
	unaryOperationFunction()
}
class "MstRing"  {
   zero: MST.Numeric
	one: MST.Numericnumber()
	bindSymbolOrNull()
	add()
	scale()
	multiply()
	unaryPlus()
	unaryMinus()
	minus()
	binaryOperationFunction()
	unaryOperationFunction()
}
class "MstField"  {
   zero: MST.Numeric
	one: MST.NumericbindSymbolOrNull()
	number()
	add()
	scale()
	multiply()
	divide()
	unaryPlus()
	unaryMinus()
	minus()
	binaryOperationFunction()
	unaryOperationFunction()
}
class "MstExtendedField"  {
   zero: MST.Numeric
	one: MST.NumericbindSymbolOrNull()
	number()
	sin()
	cos()
	tan()
	asin()
	acos()
	atan()
	sinh()
	cosh()
	tanh()
	asinh()
	acosh()
	atanh()
	add()
	sqrt()
	scale()
	multiply()
	divide()
	unaryPlus()
	unaryMinus()
	minus()
	power()
	exp()
	ln()
	binaryOperationFunction()
	unaryOperationFunction()
}
class "MstLogicAlgebra"  {
   bindSymbolOrNull()
	const()
	not()
	and()
	or()
	xor()
}
class "AutoDiffValue" {
    value: T
}
class "DerivationResult" {
    value: T
	derivativeValues: Map
	context: Field
}
class "SimpleAutoDiffField" {
    context: F
	bindings: Map
}
class "AutoDiffVariableWithDerivative" {
    identity: String
	value: T
	d: T
}
class "SimpleAutoDiffExpression" {
    field: F
	function: SimpleAutoDiffField
}
class "SimpleAutoDiffExtendedField" {
    context: F
	bindings: Map
}
interface "Symbol" {
    identity: String
}
class "StringSymbol" {
    identity: String
}
interface "SymbolIndexer" {
    symbols: List
}
class "SimpleSymbolIndexer" {
    symbols: List
}
class "BufferedLinearSpace" {
    elementAlgebra: A
	bufferFactory: BufferFactory
}
interface "LinearSolver" {
    
}
interface "LinearSpace" {
    elementAlgebra: A
}
class "LupDecomposition" {
    context: LinearSpace
	elementContext: Field
	lu: Matrix
	pivot: IntArray
	even: Boolean
}
class "MatrixBuilder" {
    linearSpace: LinearSpace
	rows: Int
	columns: Int
}
class "SymmetricMatrixFeature"  {
   
}
interface "MatrixFeature" {
    
}
interface "DiagonalFeature" {
    
}
class "ZeroFeature"  {
   
}
class "UnitFeature"  {
   
}
interface "InverseMatrixFeature" {
    inverse: Matrix
}
interface "DeterminantFeature" {
    determinant: T
}
class "LFeature"  {
   
}
class "UFeature"  {
   
}
interface "LUDecompositionFeature" {
    l: Matrix
	u: Matrix
}
interface "LupDecompositionFeature" {
    l: Matrix
	u: Matrix
	p: Matrix
}
class "OrthogonalFeature"  {
   
}
interface "QRDecompositionFeature" {
    q: Matrix
	r: Matrix
}
interface "CholeskyDecompositionFeature" {
    l: Matrix
}
interface "SingularValueDecompositionFeature" {
    u: Matrix
	s: Matrix
	v: Matrix
	singularValues: Point
}
class "MatrixWrapper" {
    origin: Matrix
	features: FeatureSet
}
class "TransposedFeature" {
    original: Matrix
}
class "VirtualMatrix" {
    rowNum: Int
	colNum: Int
	generator: (i:Int,j:Int)->T
}
class "UnstableKMathAPI" {
    
}
class "PerformancePitfall" {
    message: String
}
interface "Featured" {
    
}
interface "Feature" {
    key: FeatureKey
}
class "FeatureSet" {
    features: Map
}
interface "Loggable" {
    
}
class "ShapeMismatchException" {
    expected: IntArray
	actual: IntArray
}
interface "AlgebraND" {
    shape: IntArray
	elementContext: C
}
interface "GroupND" {
    
}
interface "RingND" {
    
}
interface "FieldND" {
    
}
interface "BufferAlgebraND" {
    strides: Strides
	bufferFactory: BufferFactory
	buffer: Buffer
}
class "BufferedGroupND" {
    shape: IntArray
	elementContext: A
	bufferFactory: BufferFactory
}
class "BufferedRingND" {
    shape: IntArray
	elementContext: R
	bufferFactory: BufferFactory
}
class "BufferedFieldND" {
    shape: IntArray
	elementContext: R
	bufferFactory: BufferFactory
}
class "BufferND" {
    strides: Strides
	buffer: Buffer
}
class "MutableBufferND" {
    strides: Strides
	mutableBuffer: MutableBuffer
}
class "DoubleFieldND" {
    shape: IntArray
}
class "ShortRingND" {
    shape: IntArray
}
interface "Structure1D" {
    dimension: Int
}
interface "MutableStructure1D" {
    
}
class "Structure1DWrapper" {
    structure: StructureND
}
class "MutableStructure1DWrapper" {
    structure: MutableStructureND
}
class "Buffer1DWrapper" {
    buffer: Buffer
}
class "MutableBuffer1DWrapper" {
    buffer: MutableBuffer
}
interface "Structure2D" {
    rowNum: Int
	colNum: Int
	shape: IntArray
	rows: List
	columns: List
}
interface "MutableStructure2D" {
    rows: List
	columns: List
}
class "Structure2DWrapper" {
    structure: StructureND
}
class "MutableStructure2DWrapper" {
    structure: MutableStructureND
}
interface "StructureFeature" {
    
}
interface "StructureND" {
    shape: IntArray
	dimension: Int
}
interface "MutableStructureND" {
    
}
interface "Strides" {
    shape: IntArray
	strides: IntArray
	linearSize: Int
}
class "DefaultStrides" {
    shape: IntArray
}
class "KMathContext" {
    
}
interface "Algebra" {
    
}
interface "GroupOperations" {
    
}
interface "Group" {
    zero: T
}
interface "RingOperations" {
    
}
interface "Ring" {
    one: T
}
interface "FieldOperations" {
    
}
interface "Field" {
    
}
interface "AlgebraElement" {
    context: C
}
interface "GroupElement" {
    
}
interface "RingElement" {
    
}
interface "FieldElement" {
    
}
class "BigIntField"  {
   zero: BigInt
	one: BigIntnumber()
	unaryMinus()
	add()
	scale()
	multiply()
	divide()
	unaryPlus()
	unaryMinus()
}
class "BigInt" {
    sign: Byte
	magnitude: Magnitude
}
interface "BufferAlgebra" {
    bufferFactory: BufferFactory
	elementAlgebra: A
}
class "BufferField" {
    bufferFactory: BufferFactory
	elementAlgebra: A
	size: Int
}
interface "LogicAlgebra" {
    
}
class "BooleanAlgebra"  {
   const()
	not()
	and()
	or()
	xor()
}
interface "ExtendedFieldOperations" {
    
}
interface "ExtendedField" {
    
}
class "DoubleField"  {
   zero: Double
	one: Doublenumber()
	binaryOperationFunction()
	add()
	multiply()
	divide()
	scale()
	sin()
	cos()
	tan()
	acos()
	asin()
	atan()
	sinh()
	cosh()
	tanh()
	asinh()
	acosh()
	atanh()
	sqrt()
	power()
	exp()
	ln()
	norm()
	unaryMinus()
	plus()
	minus()
	times()
	div()
}
class "FloatField"  {
   zero: Float
	one: Floatnumber()
	binaryOperationFunction()
	add()
	scale()
	multiply()
	divide()
	sin()
	cos()
	tan()
	acos()
	asin()
	atan()
	sinh()
	cosh()
	tanh()
	asinh()
	acosh()
	atanh()
	sqrt()
	power()
	exp()
	ln()
	norm()
	unaryMinus()
	plus()
	minus()
	times()
	div()
}
class "IntRing"  {
   zero: Int
	one: Intnumber()
	add()
	multiply()
	norm()
	unaryMinus()
	plus()
	minus()
	times()
}
class "ShortRing"  {
   zero: Short
	one: Shortnumber()
	add()
	multiply()
	norm()
	unaryMinus()
	plus()
	minus()
	times()
}
class "ByteRing"  {
   zero: Byte
	one: Bytenumber()
	add()
	multiply()
	norm()
	unaryMinus()
	plus()
	minus()
	times()
}
class "LongRing"  {
   zero: Long
	one: Longnumber()
	add()
	multiply()
	norm()
	unaryMinus()
	plus()
	minus()
	times()
}
interface "NumericAlgebra" {
    
}
interface "ScaleOperations" {
    
}
interface "NumbersAddOperations" {
    
}
interface "TrigonometricOperations" {
    
}
interface "PowerOperations" {
    
}
interface "ExponentialOperations" {
    
}
interface "Norm" {
    
}
interface "Buffer" {
    size: Int
}
interface "MutableBuffer" {
    
}
class "ListBuffer" {
    list: List
}
class "MutableListBuffer" {
    list: MutableList
}
class "ArrayBuffer" {
    array: Array
}
class "ReadOnlyBuffer" {
    buffer: MutableBuffer
}
class "VirtualBuffer" {
    size: Int
	generator: (Int)->T
}
class "BufferAccessor2D" {
    rowNum: Int
	colNum: Int
	factory: MutableBufferFactory
}
class "Row" {
    buffer: MutableBuffer
	rowIndex: Int
}
class "DoubleBuffer" {
    array: DoubleArray
}
class "DoubleBufferFieldOperations"  {
   unaryMinus()
	add()
	multiply()
	divide()
	sin()
	cos()
	tan()
	asin()
	acos()
	atan()
	sinh()
	cosh()
	tanh()
	asinh()
	acosh()
	atanh()
	power()
	exp()
	ln()
}
class "DoubleL2Norm"  {
   norm()
}
class "DoubleBufferField" {
    size: Int
}
enum "ValueFlag" {
    NAN
	MISSING
	NEGATIVE_INFINITY
	POSITIVE_INFINITY
}
interface "FlaggedBuffer" {
    
}
class "FlaggedDoubleBuffer" {
    values: DoubleArray
	flags: ByteArray
}
class "FloatBuffer" {
    array: FloatArray
}
class "IntBuffer" {
    array: IntArray
}
class "LongBuffer" {
    array: LongArray
}
class "MemoryBuffer" {
    memory: Memory
	spec: MemorySpec
}
class "MutableMemoryBuffer" {
    memory: Memory
	spec: MemorySpec
}
class "ShortBuffer" {
    array: ShortArray
}
class "ExpressionFieldTest" {
    x
}
class "InterpretTest" {
    
}
class "SimpleAutoDiffTest" {
    x
	y
	z
}
class "DoubleLUSolverTest" {
    
}
class "MatrixTest" {
    
}
class "CumulativeKtTest" {
    
}
class "BigIntAlgebraTest" {
    
}
class "BigIntConstructorTest" {
    
}
class "BigIntConversionsTest" {
    
}
class "BigIntOperationsTest" {
    
}
class "DoubleFieldTest" {
    
}
class "NDFieldTest" {
    
}
class "NumberNDFieldTest" {
    algebra
	array1
	array2
}
class "L2Norm"  {
   norm()
}
interface "AlgebraicVerifier" {
    algebra: A
}
class "FieldVerifier" {
    algebra: A
	a: T
	b: T
	c: T
	x: Number
}
class "RingVerifier" {
    algebra: A
	a: T
	b: T
	c: T
	x: Number
}
class "SpaceVerifier" {
    algebra: S
	a: T
	b: T
	c: T
	x: Number
}
class "JBigIntegerField"  {
   zero: BigInteger
	one: BigIntegernumber()
	add()
	minus()
	multiply()
	unaryMinus()
}
abstract "JBigDecimalFieldBase" {
    mathContext: MathContext
}
class "JBigDecimalField" {
    mathContext: MathContext
}
"ColumnarData" <|--- XYColumnarData
"XYColumnarData" <|--- XYErrorColumnarData
"XYColumnarData" <|--- XYZColumnarData
"Domain" <|--- DoubleDomain
"DoubleDomain" <|--- HyperSquareDomain
"DoubleDomain" <|--- UnconstrainedDomain
"DoubleDomain" <|--- UnivariateDomain
"Expression" <|--- DifferentiableExpression
"DifferentiableExpression" <|--- SpecialDifferentiableExpression
"DifferentiableExpression" <|--- FirstDerivativeExpression
"Algebra" <|--- ExpressionAlgebra
"ExpressionAlgebra" <|--- FunctionalExpressionAlgebra
"FunctionalExpressionAlgebra" <|--- FunctionalExpressionGroup
"Group" <|--- FunctionalExpressionGroup
"FunctionalExpressionGroup" <|--- FunctionalExpressionRing
"Ring" <|--- FunctionalExpressionRing
"FunctionalExpressionRing" <|--- FunctionalExpressionField
"Field" <|--- FunctionalExpressionField
"ScaleOperations" <|--- FunctionalExpressionField
"FunctionalExpressionField" <|--- FunctionalExpressionExtendedField
"ExtendedField" <|--- FunctionalExpressionExtendedField
"MST" <|--- Numeric
"MST" <|--- Unary
"MST" <|--- Binary
"NumericAlgebra" <|--- InnerAlgebra
"NumericAlgebra" <|--- MstNumericAlgebra
"Group" <|--- MstGroup
"NumericAlgebra" <|--- MstGroup
"ScaleOperations" <|--- MstGroup
"Ring" <|--- MstRing
"NumbersAddOperations" <|--- MstRing
"ScaleOperations" <|--- MstRing
"Field" <|--- MstField
"NumbersAddOperations" <|--- MstField
"ScaleOperations" <|--- MstField
"ExtendedField" <|--- MstExtendedField
"NumericAlgebra" <|--- MstExtendedField
"LogicAlgebra" <|--- MstLogicAlgebra
"Field" <|--- SimpleAutoDiffField
"ExpressionAlgebra" <|--- SimpleAutoDiffField
"NumbersAddOperations" <|--- SimpleAutoDiffField
"AutoDiffValue" <|--- AutoDiffVariableWithDerivative
"Symbol" <|--- AutoDiffVariableWithDerivative
"FirstDerivativeExpression" <|--- SimpleAutoDiffExpression
"ExtendedField" <|--- SimpleAutoDiffExtendedField
"ScaleOperations" <|--- SimpleAutoDiffExtendedField
'"" <|--- SimpleAutoDiffExtendedField
"SimpleAutoDiffField" <|--- SimpleAutoDiffExtendedField
"MST" <|--- Symbol
"Symbol" <|--- StringSymbol
"SymbolIndexer" <|--- SimpleSymbolIndexer
"LinearSpace" <|--- BufferedLinearSpace
"LupDecompositionFeature" <|--- LupDecomposition
"DeterminantFeature" <|--- LupDecomposition
"MatrixFeature" <|--- SymmetricMatrixFeature
"StructureFeature" <|--- MatrixFeature
"MatrixFeature" <|--- DiagonalFeature
"DiagonalFeature" <|--- ZeroFeature
"DiagonalFeature" <|--- UnitFeature
"MatrixFeature" <|--- InverseMatrixFeature
"MatrixFeature" <|--- DeterminantFeature
"MatrixFeature" <|--- LFeature
"MatrixFeature" <|--- UFeature
"MatrixFeature" <|--- LUDecompositionFeature
"MatrixFeature" <|--- LupDecompositionFeature
"MatrixFeature" <|--- OrthogonalFeature
"MatrixFeature" <|--- QRDecompositionFeature
"MatrixFeature" <|--- CholeskyDecompositionFeature
"MatrixFeature" <|--- SingularValueDecompositionFeature
'"Matrixbyorigin{
'
'
' @UnstableKMathAPI
' @Suppress
'overridefungetFeature:F? =
'features.getFeature
'
'overridefuntoString"
'}" <|--- MatrixWrapper
"MatrixFeature" <|--- TransposedFeature
"Matrix" <|--- VirtualMatrix
"Featured" <|--- FeatureSet
"RuntimeException" <|--- ShapeMismatchException
"Group" <|--- GroupND
"AlgebraND" <|--- GroupND
"Ring" <|--- RingND
"GroupND" <|--- RingND
"Field" <|--- FieldND
"RingND" <|--- FieldND
"AlgebraND" <|--- BufferAlgebraND
"GroupND" <|--- BufferedGroupND
"BufferAlgebraND" <|--- BufferedGroupND
"BufferedGroupND" <|--- BufferedRingND
"RingND" <|--- BufferedRingND
"BufferedRingND" <|--- BufferedFieldND
"FieldND" <|--- BufferedFieldND
"StructureND" <|--- BufferND
"MutableStructureND" <|--- MutableBufferND
"BufferND" <|--- MutableBufferND
"BufferedFieldND" <|--- DoubleFieldND
'"
'" <|--- DoubleFieldND
'"NumbersAddOperations" <|--- DoubleFieldND
'"
'" <|--- DoubleFieldND
'"ScaleOperations" <|--- DoubleFieldND
'"
'" <|--- DoubleFieldND
"ExtendedField" <|--- DoubleFieldND
"BufferedRingND" <|--- ShortRingND
'"
'" <|--- ShortRingND
"NumbersAddOperations" <|--- ShortRingND
"StructureND" <|--- Structure1D
"Buffer" <|--- Structure1D
"Structure1D" <|--- MutableStructure1D
"MutableStructureND" <|--- MutableStructure1D
"MutableBuffer" <|--- MutableStructure1D
"Structure1D" <|--- Structure1DWrapper
"MutableStructure1D" <|--- MutableStructure1DWrapper
"Structure1D" <|--- Buffer1DWrapper
"MutableStructure1D" <|--- MutableBuffer1DWrapper
"StructureND" <|--- Structure2D
"Structure2D" <|--- MutableStructure2D
"MutableStructureND" <|--- MutableStructure2D
"Structure2D" <|--- Structure2DWrapper
"MutableStructure2D" <|--- MutableStructure2DWrapper
"Feature" <|--- StructureFeature
"Featured" <|--- StructureND
"StructureND" <|--- MutableStructureND
"Strides" <|--- DefaultStrides
"Algebra" <|--- GroupOperations
"GroupOperations" <|--- Group
"GroupOperations" <|--- RingOperations
"Group" <|--- Ring
"RingOperations" <|--- Ring
"RingOperations" <|--- FieldOperations
"Ring" <|--- Field
"FieldOperations" <|--- Field
"ScaleOperations" <|--- Field
"NumericAlgebra" <|--- Field
"AlgebraElement" <|--- GroupElement
"GroupElement" <|--- RingElement
"RingElement" <|--- FieldElement
"Field" <|--- BigIntField
"NumbersAddOperations" <|--- BigIntField
"ScaleOperations" <|--- BigIntField
"Comparable" <|--- BigInt
"Algebra" <|--- BufferAlgebra
"BufferAlgebra" <|--- BufferField
"Field" <|--- BufferField
"Algebra" <|--- LogicAlgebra
"LogicAlgebra" <|--- BooleanAlgebra
"FieldOperations" <|--- ExtendedFieldOperations
'"
'" <|--- ExtendedFieldOperations
'"TrigonometricOperations" <|--- ExtendedFieldOperations
'"
'" <|--- ExtendedFieldOperations
'"PowerOperations" <|--- ExtendedFieldOperations
'"
'" <|--- ExtendedFieldOperations
"ExponentialOperations" <|--- ExtendedFieldOperations
"ExtendedFieldOperations" <|--- ExtendedField
"Field" <|--- ExtendedField
"NumericAlgebra" <|--- ExtendedField
"ScaleOperations" <|--- ExtendedField
"ExtendedField" <|--- DoubleField
"Norm" <|--- DoubleField
"ScaleOperations" <|--- DoubleField
"ExtendedField" <|--- FloatField
"Norm" <|--- FloatField
"Ring" <|--- IntRing
"Norm" <|--- IntRing
"NumericAlgebra" <|--- IntRing
"Ring" <|--- ShortRing
"Norm" <|--- ShortRing
"NumericAlgebra" <|--- ShortRing
"Ring" <|--- ByteRing
"Norm" <|--- ByteRing
"NumericAlgebra" <|--- ByteRing
"Ring" <|--- LongRing
"Norm" <|--- LongRing
"NumericAlgebra" <|--- LongRing
"Algebra" <|--- NumericAlgebra
"Algebra" <|--- ScaleOperations
"Ring" <|--- NumbersAddOperations
"NumericAlgebra" <|--- NumbersAddOperations
"Algebra" <|--- TrigonometricOperations
"Algebra" <|--- PowerOperations
"Algebra" <|--- ExponentialOperations
"Buffer" <|--- MutableBuffer
"Buffer" <|--- ListBuffer
"MutableBuffer" <|--- MutableListBuffer
"MutableBuffer" <|--- ArrayBuffer
"Buffer" <|--- ReadOnlyBuffer
"Buffer" <|--- VirtualBuffer
"MutableBuffer" <|--- Row
"MutableBuffer" <|--- DoubleBuffer
"ExtendedFieldOperations" <|--- DoubleBufferFieldOperations
"Norm" <|--- DoubleL2Norm
"ExtendedField" <|--- DoubleBufferField
"Norm" <|--- DoubleBufferField
"Buffer" <|--- FlaggedBuffer
"FlaggedBuffer" <|--- FlaggedDoubleBuffer
'"
'" <|--- FlaggedDoubleBuffer
"Buffer" <|--- FlaggedDoubleBuffer
"MutableBuffer" <|--- FloatBuffer
"MutableBuffer" <|--- IntBuffer
"MutableBuffer" <|--- LongBuffer
"Buffer" <|--- MemoryBuffer
"MemoryBuffer" <|--- MutableMemoryBuffer
'"
'" <|--- MutableMemoryBuffer
"MutableBuffer" <|--- MutableMemoryBuffer
"MutableBuffer" <|--- ShortBuffer
"Norm" <|--- L2Norm
"RingVerifier" <|--- FieldVerifier
"SpaceVerifier" <|--- RingVerifier
"AlgebraicVerifier" <|--- SpaceVerifier
"Ring" <|--- JBigIntegerField
"NumericAlgebra" <|--- JBigIntegerField
"Field" <|--- JBigDecimalFieldBase
"PowerOperations" <|--- JBigDecimalFieldBase
"NumericAlgebra" <|--- JBigDecimalFieldBase
"ScaleOperations" <|--- JBigDecimalFieldBase
"JBigDecimalFieldBase" <|--- JBigDecimalField
@enduml