How to multiply two vectors??

Multiplication element by element:

Vanuxem Gregory replies:

Try

a:= vector [1,2,3,5,6]

(1)

map(*,a,a)

(2)

otherwise use Matrix:

a:= matrix [[1,2,3,4,5,6]]

(3)

a * transpose a

(4)

Tim Daly replies:

make three vectors

)clear all

   All user variables and function definitions have been cleared.
u : VECTOR INT := new(5,12)

(5)

v : VECTOR INT := vector([1,2,3])

(6)

w : VECTOR INT := vector([2,3,4])

(7)

multiply them

cross(v,w)

(8)

dot product

dot(v,w)

(9)

ask for the length

#(v)

(10)

access an element

v.2

(11)

set an element

v.3 := 99

(12)

show the vector

v

(13)

multiply by a constant on either side

5 * v

(14)

v * 7

(15)

add them

v + w

(16)

substract them

v - w

(17)

display all possible functions

)show Vector(Integer)

 Vector Integer is a domain constructor.
 Abbreviation for Vector is VECTOR
 This constructor is exposed in this frame.
 Issue )edit /usr/local/lib/axiom/target/x86_64-unknown-linux/../../src/algebra/VECTOR.spad
to see algebra source code for VECTOR 

------------------------------- Operations --------------------------------

 #? : % -> NonNegativeInteger          ?*? : (Integer,%) -> %
 ?*? : (%,Integer) -> %                ?+? : (%,%) -> %
 ?-? : (%,%) -> %                      -? : % -> %
 ?<? : (%,%) -> Boolean                ?<=? : (%,%) -> Boolean
 ?=? : (%,%) -> Boolean                ?>? : (%,%) -> Boolean
 ?>=? : (%,%) -> Boolean               coerce : % -> OutputForm
 concat : (Integer,%) -> %             concat : List % -> %
 concat : (%,Integer) -> %             concat : (%,%) -> %
 construct : List Integer -> %         convert : % -> InputForm
 copy : % -> %                         copyInto! : (%,%,Integer) -> %
 cross : (%,%) -> %                    delete : (%,Integer) -> %
 dot : (%,%) -> Integer                ?.? : (%,Integer) -> Integer
 empty : () -> %                       empty? : % -> Boolean
 entries : % -> List Integer           entry? : (Integer,%) -> Boolean
 eq? : (%,%) -> Boolean                eval : (%,Equation Integer) -> %
 eval : (%,Integer,Integer) -> %       fill! : (%,Integer) -> %
 first : % -> Integer                  hash : % -> SingleInteger
 index? : (Integer,%) -> Boolean       indices : % -> List Integer
 insert : (%,%,Integer) -> %           latex : % -> String
 length : % -> Integer                 magnitude : % -> Integer
 max : (%,%) -> %                      maxIndex : % -> Integer
 member? : (Integer,%) -> Boolean      members : % -> List Integer
 merge : (%,%) -> %                    min : (%,%) -> %
 minIndex : % -> Integer               parts : % -> List Integer
 position : (Integer,%) -> Integer     qelt : (%,Integer) -> Integer
 remove : (Integer,%) -> %             removeDuplicates : % -> %
 reverse : % -> %                      reverse! : % -> %
 sample : () -> %                      sort : % -> %
 sort! : % -> %                        sorted? : % -> Boolean
 vector : List Integer -> %            zero : NonNegativeInteger -> %
 ?~=? : (%,%) -> Boolean
 any? : ((Integer -> Boolean),%) -> Boolean
 count : (Integer,%) -> NonNegativeInteger
 count : ((Integer -> Boolean),%) -> NonNegativeInteger
 delete : (%,UniversalSegment Integer) -> %
 elt : (%,Integer,Integer) -> Integer
 ?.? : (%,UniversalSegment Integer) -> %
 eval : (%,List Equation Integer) -> %
 eval : (%,List Integer,List Integer) -> %
 every? : ((Integer -> Boolean),%) -> Boolean
 find : ((Integer -> Boolean),%) -> Union(Integer,"failed")
 insert : (Integer,%,Integer) -> %
 less? : (%,NonNegativeInteger) -> Boolean
 map : (((Integer,Integer) -> Integer),%,%) -> %
 map : ((Integer -> Integer),%) -> %
 map! : ((Integer -> Integer),%) -> %
 merge : (((Integer,Integer) -> Boolean),%,%) -> %
 more? : (%,NonNegativeInteger) -> Boolean
 new : (NonNegativeInteger,Integer) -> %
 outerProduct : (%,%) -> Matrix Integer
 position : (Integer,%,Integer) -> Integer
 position : ((Integer -> Boolean),%) -> Integer
 qsetelt! : (%,Integer,Integer) -> Integer
 reduce : (((Integer,Integer) -> Integer),%,Integer,Integer) -> Integer
 reduce : (((Integer,Integer) -> Integer),%,Integer) -> Integer
 reduce : (((Integer,Integer) -> Integer),%) -> Integer
 remove : ((Integer -> Boolean),%) -> %
 select : ((Integer -> Boolean),%) -> %
 setelt : (%,Integer,Integer) -> Integer
 setelt : (%,UniversalSegment Integer,Integer) -> Integer
 size? : (%,NonNegativeInteger) -> Boolean
 sort : (((Integer,Integer) -> Boolean),%) -> %
 sort! : (((Integer,Integer) -> Boolean),%) -> %
 sorted? : (((Integer,Integer) -> Boolean),%) -> Boolean
 swap! : (%,Integer,Integer) -> Void