Kdtyjb

This is a more "TeX" approach. The number of rows is arbitrary. The columns are aligned right by default, but can be c or l as well:

documentclass{article}



makeatletter

newcommand{Spvek}[2][r]{%

  gdef@VORNE{1}

  left(hskip-arraycolsep%

    begin{array}{#1}vekSp@lten{#2}end{array}%

  hskip-arraycolsepright)}



defvekSp@lten#1{xvekSp@lten#1;vekL@stLine;}

defvekL@stLine{vekL@stLine}

defxvekSp@lten#1;{deftemp{#1}%

  ifxtempvekL@stLine

  else

    ifnum@VORNE=1gdef@VORNE{0}

    else@arraycrfi%

    #1%

    expandafterxvekSp@lten

  fi}

makeatother





begin{document}

[

Spvek{1;-2} quad Spvek[l]{1;-2;3}quad Spvek[c]{1;-2;-3}quadSpvek{1;2;-3;4}

]

end{document}

Output will be:

For vectors with only two elements, or any doublet you want to express in column form, there is a standard LaTeX command in math mode $binom{a}{b}$ or alternatively ${n choose k}$. These look nice with tight vertically lengthened parentheses.

Since you specified only wanting two or three arguments (not an arbitrary number of them, as others here have given solutions for), you can use the xparse package to define commands with optional braced arguments. Something like (untested)

DeclareDocumentCommand colvec {mmg} {%

  IfNoValueTF #3 {%

    twocolvec {#1}{#2}

  }{%

    threecolvec {#1}{#2}{#3}

  }%

}

Where the two intermediate functions (defined as appropriate) typeset the array as appropriate.

I would to supplement the solution above about Spvek by Peter B.
Yes, it is a more "TeX" approach but pure "TeX" approach is in two lines only:

defspvec#1{left(vcenter{halign{hfil$##$hfilcr spvecA#1;;}}right)}

defspvecA#1;{if;#1;else #1cr expandafter spvecA fi}



$spvec{1;2;3} + spvec{1;2;-3;4} + spvec{1;2}$

This solution will be work in LaTeX too because only TeX primitives are used here.

Here is my KISS-like solution (which is just a wrapper for pmatrix from the amsmath package, inspired by Garrys answer):

newcommand{myvec}[1]{ensuremath{begin{pmatrix}#1end{pmatrix}}}

Usage:

myvec{x\y\z}

The good thing is, you don't need to specify a number of elements or anything. You can just add more elements with \. It also looks tidier in the tex-file then using the pmatrix environment itself.

You can also use it for row-vectors:

myvec{a&b&c}

(For completion: Matrices work aswell, obviously: myvec{a&b \ c&d})

Years later and not very tex-y, but for some reason I really wanted to use commas as separators and ended up putting together the following:

usepackage{iftex}

RequireLuaTeX

usepackage{amsmath}

usepackage{luacode}

begin{luacode*}

mycolvec = { }

function mycolvec.replace(input)

  tex.sprint(

    "\ensuremath{\begin{pmatrix}"

      .. string.gsub(input, ",", " \\ ")

      .. "\end{pmatrix}}")

end

end{luacode*}

defcolvec#1{directlua{mycolvec.replace("#1")}}

Which, when added to the header, allows you to write out column vectors like this:

colvec{1, 2, 3}

colvec{8,6,7,5,3,0,9}

This requires that you compile your tex with lualatex instead of xetex or pdftex, but that shouldn't affect the rest of your document.

The seperator can be changed to any arbitrary character by changing the "," on the .. string.gsub(... line.

EDIT:
This method breaks when entering tokens (i.e. colvec{1 cdot 2, 2 cdot 3}), for the reasons described here. As such I'll recommend egreg's answer on a related question, which provides the functionality I claim here without the same problem.

This post presents another possible approach. It improves on this earlier post above. The idea is to use a similar plain TeX mechanism, but wrap it up in amsmaths high level pmatrix environment. This helps with fractions for example. The interface with parentheses is the same as used by PSTricks. Here is a working example:

documentclass[margin=2pt]{standalone}

usepackage{amsmath}



makeatletter

defvector(#1){%

mathchoice%

    {pmatrix@i{vector@i#1,,}}%

    {pmatrix@ii{vector@i#1,,}}%

    {}% scriptstyle too small,

    {}% ss style too small.

}

defvector@i#1,{if,#1,else{#1}crexpandaftervector@ifi}

defpmatrix@i#1{begin{pmatrix}#1end{pmatrix}}

defpmatrix@ii#1{left(!begin{smallmatrix}#1end{smallmatrix}!right)}

makeatother



begin{document}

$displaystylevector(-3,+4,5)$ and $vector(-3,+4,5)$

end{document}

When typesetting vectors with lots of fractions it is advisable to increase vertical spacing with:

renewcommand{arraystretch}{1.1}% stretch value 1.1 for example

Because the macros make use of the @i notation the code will have to be placed inside at makeatletter - makeatother wrapping before document begins.

See here for a similar solution for row vectors.

I can offer a macro colvec within whose argument you can supply an arbitrary amount of undelimited arguments whereof each one will be taken for a component of the one-column-vector:

documentclass{article}

usepackage{amsmath}



makeatletter

%%=============================================================================

%% Paraphernalia:

%%    UD@firstoftwo, UD@secondoftwo, UD@Exchange, UD@PassFirstToSecond,

%%    UD@CheckWhetherNull, UD@CheckWhetherBlank, UD@ExtractFirstArg

%%=============================================================================

newcommandUD@firstoftwo[2]{#1}%

newcommandUD@secondoftwo[2]{#2}%

newcommandUD@Exchange[2]{#2#1}%

newcommandUD@PassFirstToSecond[2]{#2{#1}}%

%%-----------------------------------------------------------------------------

%% Check whether argument is empty:

%%.............................................................................

%% UD@CheckWhetherNull{<Argument which is to be checked>}%

%%                     {<Tokens to be delivered in case that argument

%%                       which is to be checked is empty>}%

%%                     {<Tokens to be delivered in case that argument

%%                       which is to be checked is not empty>}%

%%

%% The gist of this macro comes from Robert R. Schneck's ifempty-macro:

%% <https://groups.google.com/forum/#!original/comp.text.tex/kuOEIQIrElc/lUg37FmhA74J>

newcommandUD@CheckWhetherNull[1]{%

  romannumeral0expandafterUD@secondoftwostring{expandafter

  UD@secondoftwoexpandafter{expandafter{string#1}expandafter

  UD@secondoftwostring}expandafterUD@firstoftwoexpandafter{expandafter

  UD@secondoftwostring}expandafterexpandafterUD@firstoftwo{ }{}%

  UD@secondoftwo}{expandafterexpandafterUD@firstoftwo{ }{}UD@firstoftwo}%

}%

%%-----------------------------------------------------------------------------

%% Check whether argument is blank (empty or only spaces):

%%.............................................................................

%% -- Take advantage of the fact that TeX discards space tokens when

%%    "fetching" _un_delimited arguments: --

%% UD@CheckWhetherBlank{<Argument which is to be checked>}%

%%                      {<Tokens to be delivered in case that

%%                        argument which is to be checked is blank>}%

%%                      {<Tokens to be delivered in case that argument

%%                        which is to be checked is not blank}%

newcommandUD@CheckWhetherBlank[1]{%

  romannumeralexpandafterexpandafterexpandafterUD@secondoftwo

  expandafterUD@CheckWhetherNullexpandafter{UD@firstoftwo#1{}.}%

}%

%%-----------------------------------------------------------------------------

%% Extract first inner undelimited argument:

%%

%%   UD@ExtractFirstArg{ABCDE} yields  {A}

%%

%%   UD@ExtractFirstArg{{AB}CDE} yields  {AB}

%%.............................................................................

newcommandUD@RemoveTillUD@SelDOm{}%

longdefUD@RemoveTillUD@SelDOm#1#2UD@SelDOm{{#1}}%

newcommandUD@ExtractFirstArg[1]{%

  romannumeral0%

  UD@ExtractFirstArgLoop{#1UD@SelDOm}%

}%

newcommandUD@ExtractFirstArgLoop[1]{%

  expandafterUD@CheckWhetherNullexpandafter{UD@firstoftwo{}#1}%

  { #1}%

  {expandafterUD@ExtractFirstArgLoopexpandafter{UD@RemoveTillUD@SelDOm#1}}%

}%

%%=============================================================================

%% Process an arbitrary amount of undelimited arguments as 

%% a one-column-vector:

%%

%% The macro colvec processes an undelimited argument which in

%% turn consists of an arbitrary amount of undelimited arguments.

%% Each of these undelimited arguments is taken for a row/component

%% of a one-column-vector.

%%

%% You can have spaces between undelimited arguments as (La)TeX does discard

%% spaces that precede undelimited arguments.

%%

%% You can omit braces with undelimited arguments that consist of a 

%% single token. 

%%-----------------------------------------------------------------------------

newcommandcolvec[1]{%

  colvecloop{#1}{}%

}%

newcommandcolvecloop[2]{%

  UD@CheckWhetherBlank{#1}{%

     begin{pmatrix}#2end{pmatrix}%

  }{%

      expandafterexpandafterexpandafter

      expandafterexpandafterexpandafter

      expandafterUD@PassFirstToSecond

      expandafterexpandafterexpandafter

      expandafterexpandafterexpandafter

      expandafter{expandafterexpandafter

      expandafterUD@ExchangeUD@ExtractFirstArg{#1}{#2}\}%

      {expandaftercolvecloopexpandafter{UD@firstoftwo{}#1}}%

  }%

}%

makeatother



begin{document}



verb|$colvec{{a}{b}{c}{d}}$| yields:

$colvec{{a}{b}{c}{d}}$



verb|$colvec{ {a} {b} {c} {d} {e} }$| yields:

$colvec{ {a} {b} {c} {d} {e} }$



verb|$colvec{ {a} {b} {c} {d} {e}fg }$| yields:

$colvec{ {a} {b} {c} {d} {e}fg }$



end{document}