Kdtyjb

I know I'm late to the party here, but I would use Sage and SageTeX:

documentclass{article}

usepackage{sagetex}

begin{document}

section{Problem}



begin{sagesilent}

a = ZZ.random_element(-10,10)

while a == 0:

   a = ZZ.random_element(-10,10)

b = ZZ.random_element(-10,10)

c = ZZ.random_element(-10,10)

poly = a*x^2 + b*x + c

end{sagesilent}



Let (x_1) and (x_2) be the roots of (sage{poly}=0). 

Find  (x_1x_2).



section{Solution}

[

x_1x_2=sage{c/a}.

]



sageplot{plot(poly) }



end{document}

The output looks like this:

The lcg package contains macros to generate (pseudo) random numbers. A little example (the plot is also generated but using TikZ):

documentclass{article}

usepackage[counter=coefa,first=-8, last=12]{lcg}

usepackage{pgfplots}



begin{document}



randarabic{coefa}

letCoefathecoefa



chgrand[counter=coefb]

randarabic{coefb}

letCoefbthecoefb



chgrand[counter=coefc]

randarabic{coefc}

letCoefcthecoefc



section{Problem}

Let (x_1) and (x_2) be the roots of ( Coefa x^2 +Coefb x + Coefc =0). Find  (x_1x_2).



section{Solution}

[

x_1x_2=frac{Coefc}{Coefa}

]





begin{tikzpicture}

begin{axis}[

  xlabel=$x$,

  ylabel={$f(x) = Coefa x^2 + Coefb x + Coefc $}

]

addplot[color=orange,thick] {Coefa*x^2 + Coefb* x + Coefc};

end{axis}

end{tikzpicture}



end{document}

Of course, when compiling my example you'll get different values for the corfficients, so a different equation and plot will be obtained.

To simplify the fractions, you can use Euclid's Method, using the minimal below with

reduceFrac{27}{81}

$frac{rfNumer}{rfDenom}$

will give you 1/3. To simplify to a round number is more difficult, as you need to check if there is a remainder left over, so you will need a decimal to fraction conversion routine. See How to break out of a loop at the end of the code, you will find how to use the macros to convert for example 0.375 to the fractional approximation 768/2048. No guarantees for its accuracy, needs a bit of refinement.

documentclass{article}

begin{document}

makeatletter

% Use Euclid's Algorithm to find the greatest 

% common divisor of two integers.

defgcd#1#2{{% #1 = a, #2 = b

    ifnum#2=0 edefnext{#1}else

        @tempcnta=#1 @tempcntb=#2 divide@tempcnta by@tempcntb

        multiply@tempcnta by@tempcntb  % q*b

        @tempcntb=#1

        advance@tempcntb by-@tempcnta % remainder in @tempcntb

        ifnum@tempcntb=0

            @tempcnta=#2

            ifnum@tempcnta < 0 @tempcnta=-@tempcntafi

            xdefgcd@next{noexpand%

                defnoexpandthegcd{the@tempcnta}}%

        else

            xdefgcd@next{noexpandgcd{#2}{the@tempcntb}}%

        fi

    fi}gcd@next

}

newcommandreduceFrac[2]

{%

   gcd{#1}{#2}{@tempcnta=#1 divide@tempcnta bythegcd

   @tempcntb=#2 divide@tempcntb bythegcd

   ifnum@tempcntb<0relax

      @tempcntb=-@tempcntb

        @tempcnta=-@tempcnta

    fi

    xdefrfNumer{the@tempcnta}

    xdefrfDenom{the@tempcntb}}%

}



reduceFrac{27}{81}

$frac{rfNumer}{rfDenom}$

makeatother

end{document}

A solution with Lua that handles coefficients that are smaller than 2 correctly.

% Compile with lualatex.

documentclass{article}

usepackage{luacode}

begin{luacode*}

function gcd (a,b) 

    if b == 0 then

        return a

    end

    return gcd(b, a % b)

end



function makeproblem ()

    local a,b,c

    a = math.random (-10,10)

    if a == 0 then a = 1 end

    b = math.random (-10,10)

    c = math.random (-10,10)



    -- Pretty-print the equation.

    if a == - 1 then

        tex.sprint('-')

    elseif a ~= 1 then

        tex.sprint(a)

    end

    tex.sprint( 'x^2' )

    if b ~= 0 then

        if b > 0 then tex.sprint('+') end

        if b ~= 1 and b ~= -1 then tex.sprint(b) end

        if b == -1 then tex.sprint('-') end

        tex.sprint('x')

    end

    if c ~= 0 then

        if c > 0 then tex.sprint('+') end

        tex.sprint(c)

    end

    tex.sprint('=0')



    -- Simplify the solution

    local d

    d = gcd(a,c)

    a = a/d

    c = c/d



    local sign = 1

    if a < 0 then 

        sign = -1

        a    = -a

    end

    if c < 0 then

        sign = -sign

        c    = -c

    end



    -- Store the solution in solution.

    tex.sprint('\gdef\solution{')

    if sign < 0 then tex.sprint('-') end

    if a == 1 or c == 0 then

        tex.sprint(c)

    else

        tex.sprint('\frac{' .. c  ..'}{'.. a ..'}')

    end

    tex.sprint('}')

end

end{luacode*}

newcommandmakeproblem{directlua{makeproblem()}}



begin{document}



section{Problem}

Let (x_1) and (x_2) be the roots of (makeproblem). Find  (x_1x_2).



section{Solution}

[

x_1x_2=solution

]



end{document}

Funny problem and it's a possibility to test TL 2011 with my package tkz-fct. This package calls tkz-tool-arith.tex and inside this file I define gcd and tkzReducFrac. gcd now is a part of pgf CVS with isprime isodd and iseven.
I use the code of Jake for random. The study of the function is not completed, I give this solution only to see what we can make with little tools.
I compile with xelatex and with -shell-escape because tkz-fct uses only gnuplot
tkzReducFrac defines two macros tkzMathFirstResultand tkzMathSecondResult

documentclass{article}

usepackage{tkz-fct}

begin{document}

section{Problem}



pgfmathsetseed{1}

pgfmathtruncatemacrocoeffa{random(2,10)}

pgfmathtruncatemacrocoeffb{random(2,10)}

pgfmathtruncatemacrocoeffc{random(2,10)}



Let (x_1) and (x_2) be the roots of (coeffa x^2 +coeffb x +coeffc=0). Find  (x_1x_2).



tkzReducFrac{coeffc}{coeffa}

section{Solution}

[

x_1x_2=frac{tkzMathFirstResult}{tkzMathSecondResult}

]



% only to make some tests

pgfmathsetmacrodiscrimin{coeffb*coeffb-4*coeffa*coeffc}   

pgfmathparse{ifthenelse(notless(discrimin,0)==1,">=0","<0")} 



$Delta=b^2-4ac=discriminpgfmathresult$  



$a=coeffa$



pgfmathsetmacroxmid{-coeffb/(2*coeffa)}     

pgfmathsetmacroxmin{xmid-5} % to adjust the grid and the background

pgfmathsetmacroxmax{xmid+5} 



$-b/(2a)=xmid$



% minimum to adjust vertically but it's possible to use a better code

ifnumcoeffa > 0 

     pgfmathsetmacroymin{-1-discrimin/(coeffa*coeffa)}

     pgfmathsetmacroymax{ymin+10}

 else 

   pgfmathsetmacroymax{-1-discrimin/(coeffa*coeffa)}

   pgfmathsetmacroymin{ymax-10}    

fi





begin{tikzpicture}

      tkzInit[xmin=xmin,xmax=xmax,ymin=ymin,ymax=ymax]  

               tkzGrid

               tkzAxeXY 

tkzFct[blue,thick]{coeffa*x*x+coeffb*x+coeffc}

end{tikzpicture}  



end{document}

MATLAB version, possibly adaptable to Octave:

First, download my parsetex.m function to somewhere in your search path. Next,
make a template .tex file named foo-gradingkey.tex, with contents like

documentclass{article}



begin{document}

Hello, **studentName**.



section{Problem}

% ^^a=round(9*rand)+1;^^

% ^^b=round(10*rand);^^

% ^^c=round(10*rand);^^

Let (x_1) and (x_2) be the roots of (**a** x^2 + **b** x + **c**=0).

Find  (x_1x_2). 



section{Solution}

[ x_1x_2=frac{**c**}{**a**}= **c/a** ] 

end{document}

Paired double carets and paired double asterisks indicate MATLAB code to be evaluated. Material in paired double carets will remain in the final file, while material in pared double asterisks will be replaced with the evaluated result.

Run the following command in MATLAB:

parsetex('foo-%s.tex',{'Mike Renfro'},{'renfro'});

which results in the following message on the command line:

Creating file foo-renfro.tex: done

The contents of foo-renfro.tex will be something like

documentclass{article}



begin{document}

Hello, Mike Renfro.



section{Problem}

% ^^a=round(9*rand)+1;^^

% ^^b=round(10*rand);^^

% ^^c=round(10*rand);^^

Let (x_1) and (x_2) be the roots of (10 x^2 + 2 x + 10=0).

Find  (x_1x_2). 



section{Solution}

[ x_1x_2=frac{10}{10}= 1 ] 

end{document}

It's not perfect, since I've not yet managed to get it to reduce fractions to simplest form, i.e., 2/5 ends up being evaluated as 0.4.