Solver Factoring using the AC method (Factor by Grouping)

Source code of 'Factoring using the AC method (Factor by Grouping)'

This Solver (Factoring using the AC method (Factor by Grouping)) was created by by jim_thompson5910(35256)

: View Source, Show, Put on YOUR site
About jim_thompson5910: If you need more math help, then you can email me. I charge $2 for steps, or $1 for answers only. Email: jim_thompson5910@hotmail.com Website: http://www.freewebs.com/jimthompson5910/home.html

==section input

Here is another way to factor quadratics. This solver will show you how to factor any quadratic by grouping.

Enter integer (whole number) coefficients of the quadratic in the form  {{{ax^2+bx+c}}} where c must not equal zero. For instance, to factor the quadratic {{{2x^2+8x+6}}}, let a=2, b=8, and c=6.

a=*[input my_a1=2] b=*[input my_b1=8] c=*[input my_c1=6]

Now enter the variable of the quadratic

*[input variable1=x]

note: I have not fully tested this solver (there might be a special case I have overlooked), so check your answer by foiling. If you come across an error, in either the answer or the step-by-step guide, please tell me about it.

==section solution

perl

if(length($variable1) > 1)
{
 print "Error: make sure the variable is ONE letter";
 goto END;
}

my $input = "$my_a1*$variable1^2 + $my_b1*$variable1 + $my_c1";
$input =~ s/\s//g;
$input =~ s/^1\*//;
$input =~ s/\+\-/\-/g;
$input =~ s/\-1\*/\-/g;
$input =~ s/\+1\*/\+/g;

## input
#my $input = $specialinput;
#chomp(my $input=<>);
#my $input="x^2+x-120";
$input=~s/\s//g;
my $ans=factor_quadratic_gcf($input,1,1);
## end input

# allows for exporting symbols, variables, subroutines, etc
#require Exporter;
# used for inheritance
#our @ISA = qw(Exporter);
#exported only if the caller explicitly asks for them by listing them in the use statement
#our @EXPORT_OK = qw(factor_quadratic_gcf);

## import any subroutines, variables, etc.

# needed to factor out GCF
#use factor_out_gcf2 qw (factor_out_gcf);
#
# factor by grouping (ie AC method)
#use factor_quadratic qw (factor_quadratic);

## Sort numbers in ascending order
## Input: list of things to sort: ARRAY
## Output: list of sorted things: ARRAY
## Usage: ARRAY = my_sort(ARRAY)
sub my_sort
{
 my @array=@_;
 for (my $i=0;$i<@array;$i++)
 {
 for (my $j=0;$j<@array;$j++)
 {
 if($array[$i]<$array[$j] and $i!=$j)
 { #print " ",join(",",@array)," ";
 my $temp=$array[$i];
 $array[$i]=$array[$j];
 $array[$j]=$temp;
 }
 }
 }
 return @array;
}

sub gcf {
  my ($x, $y) = @_;
  ($x, $y) = ($y, $x % $y) while $y;
  return $x;
}

sub multigcf {
  my $x = shift;
  $x = gcf($x, shift) while @_;
  return $x;
}

sub generate_terms
{
 my $expression=$_[0];
 #my $degree=$1 if $expression=~m/\^(\d+)/;
 $expression=~s/\s//g;
 $expression=~s/\-/\+\-/g; # change each - into +-
 $expression=~s/^\+//; # remove first +
 $expression=~s/\(\+/\(/g; # replace (+ with (
 #$expression=~s/([a-z])(\+|\-)/$1\^1$2/g; # replace 5x with 5x^1
 #$expression=~s/([a-z])$/$1\^1/g; # replace 5x with 5x^1
 $expression=~s/(\+|\-)([a-z])/$1 1 $2/g; # replace +x with +1x
 $expression=~s/^([a-z])/1 $1/g; # replace +x with +1x
 $expression=~s/\++/\+/g;
 $expression=~s/\s//g; #print " MODULE GENERATE TERMS: $expression ";
 my @terms=split(/\+/,$expression);
 return @terms;
}

#extract coefficients from multivariate polynomial. Coefficients collected in order they appear
#eg x+2y-1/3z ---> 1, 2, -1/3
sub multivariate_coefficient
{
  my $expression=$_[0];
  #my $degree=$1 if $expression=~m/\^(\d+)/;
  $expression=~s/\s//g;
  $expression=~s/\-/\+\-/g;                      # change each - into +-
  $expression=~s/^\+//;                          # remove first +
  $expression=~s/([a-z])(\+|\-)/$1\^1$2/g;       # replace 5x with 5x^1
  $expression=~s/([a-z])$/$1\^1/g;               # replace 5x with 5x^1
  $expression=~s/(\+|\-)([a-z])/$1 1 $2/g;       # replace +x with +1x
  $expression=~s/(^|=)([a-z])/$1 1 $2/g;         # replace +x with +1x
  $expression=~s/\s//g;                          # remove spaces

#print "SUB multivariate_coefficient: $expression ";

$expression=~s/\s//g;
 my @terms=split(/\+/,$expression);
 my @coefficients;
 for(my $i=0;$i<@terms;$i++)
 {
 push(@coefficients,$1) if $terms[$i]=~m/^(.*?)[a-z]/;
 push(@coefficients,$terms[$i]) if $terms[$i]!~m/[a-z]/;
 }
 #@coefficients=map{s/^\-$/\-1/g;$_} @coefficients;
 @coefficients=map{s/\^1$//g;$_} @coefficients;
 return @coefficients;
}

sub monomial_mult_div {

#if(@_<2)
#{print "ERROR!";
#return;}

my $op=pop(@_);

if(($op ne '*')&&($op ne '/'))
{print "ERROR! Missing Operator ";
return;}

my ($exp1,$exp2)=@_;

if($exp1 eq $exp2)
{if($op eq '/')
  {return 1;}
}

if(@_<2)
{print "ERROR! SIZE=".@_."";
return;}

$exp1.=",";
$exp1=~s/([a-z])([a-z])/$1\^1$2/g;
$exp1=~s/([a-z]),/$1\^1/g;
$exp1=~s/,//g;
$exp1=~s/([a-z])(\d+)/$1\^$2/g; # replace x2 with x^2

$exp2.=",";
$exp2=~s/([a-z])([a-z])/$1\^1$2/g;
$exp2=~s/([a-z]),/$1\^1/g;
$exp2=~s/,//g;
$exp2=~s/([a-z])(\d+)/$1\^$2/g; # replace x2 with x^2

my @coefficients;
if($exp1=~m/^(\-\d+|\d+)/)
{push(@coefficients,$1);}
elsif($exp1=~m/^\-/)
{push(@coefficients,-1);}
else
{push(@coefficients,1);}

if($exp2=~m/^(\-\d+|\d+)/)
{push(@coefficients,$1);}
elsif($exp2=~m/^\-/)
{push(@coefficients,-1);}
else
{push(@coefficients,1);}

my (%var_hash,%int_exp_hash,$reduced_coefficient);

if($op eq '*')
{
      for my $i ('a'..'z')
        {if($exp1=~m/$i\^(\-\d+|\d+)/)
           {$var_hash{$i}+=$1;
            $int_exp_hash{$i}.="+$1";}
         if($exp2=~m/$i\^(\-\d+|\d+)/)
           {$var_hash{$i}+=$1;
            $int_exp_hash{$i}.="+$1";}
        }
        $reduced_coefficient=$coefficients[0]*$coefficients[1];

}
if($op eq '/')
{    #print "MULT";
      for my $i ('a'..'z')
        {if($exp1=~m/$i\^(\-\d+|\d+)/)
           {$var_hash{$i}+=$1;
            $int_exp_hash{$i}.="+$1";}
         if($exp2=~m/$i\^(\-\d+|\d+)/)
           {$var_hash{$i}-=$1;
            $int_exp_hash{$i}.="-$1";}
        }
    $reduced_coefficient=reduce(@coefficients);
    $reduced_coefficient=~s/\/1$//g;

}

my $ans;
#if(($reduced_coefficient!=1)||($reduced_coefficient!=-1))
#{$ans.="$reduced_coefficient" if $reduced_coefficient!~/\//;
# $ans.="($reduced_coefficient)" if $reduced_coefficient=~/\//;}
#if($reduced_coefficient==-1)
#{$ans.="-";}

$ans.="$reduced_coefficient" if $reduced_coefficient!~/\//;
$ans.="($reduced_coefficient)" if $reduced_coefficient=~/\//;

my $int_ans;
for my $i ('a'..'z')
        {$int_exp_hash{$i}=~s/^\+// if exists($int_exp_hash{$i});
         $int_ans.="$i^($int_exp_hash{$i})" if exists($var_hash{$i});
         $ans.="$i^$var_hash{$i}" if exists($var_hash{$i});
        }

$ans=~s/^\-1([a-z])/\-$1/;
$ans=~s/^1([a-z])/$1/;

#print " SUB--->{{{$ans}}}$int_ans ";
#return ($int_ans,$ans);
return $ans;

}

# take string "a/b" convert it to array (a,b) or take "a" and convert to (a,1)
sub generate_fraction {
  my $exp=$_[0];
  my @array=split(/\//,$exp);
  #die "ERROR: Division by zero" if $array[1]==0;
  $array[1]=1 if @array==1;
  return @array;
}

# reduce fraction of integer numerator/denominator
sub reduce{
 die "Error: no value entered " if @_==0;
 my @a=generate_fraction($_[0]) if @_==1; ## if input arg is a string
 @a=@_ if @_>1; ## if input arg is an array

if(@a>2)
  {die "ERROR: More than 2 input arguments";}

foreach (@a)
   {die "Cannot handle decimal numbers " if $_=~m/\./;}

if($a[1]==0)
   {die "ERROR: Division by zero";}

if($a[0]==0)
  {return $a[0];}

my $gcf=gcf($a[0],$a[1]);
 $a[0]/=$gcf;
 $a[1]/=$gcf;
 my $answer_string=join("/",@a);
 $answer_string=~s/\/1$//; # remove denominator of 1

## Last few lines allow for overloading return values
  #-- undefined context -- return nothing
  return if ( ! defined wantarray );
  #-- list/array context -- return array
  return @a if ( wantarray );
  #-- neither undefined nor list context, return scalar
  return $answer_string;
}

sub lcm {
  return($_[0] * $_[1] / gcf($_[0], $_[1]));
}

#sub generate_fraction {
#  my $exp=$_[0];
#  my @array=split(/\//,$exp);
#  $array[1]=1 if @array==1;
#  return @array;
#}

# reduce fraction of integer numerator/denominator
sub reduce_OLD{
 die "Error: no value entered " if @_==0;
 my @a=generate_fraction($_[0]) if @_==1; ## if input arg is a string
 @a=@_ if @_>1; ## if input arg is an array

## if one operand is a decimal number, just divide
 if(($a[0]=~m/\./) or ($a[1]=~m/\./))
  {
     return $a[0]/$a[1];
  }

if(@a>2)
  {die "ERROR: More than 2 input arguments";}

foreach (@a)
   {die "Cannot handle decimal numbers " if $_=~m/\./;}

if($a[1]==0)
   {die "ERROR: Division by zero";}

if($a[0] eq '0')
  {return $a[0];}

my $gcf=gcf($a[0],$a[1]);
 $a[0]/=$gcf;
 $a[1]/=$gcf;

my $answer_string=join("/",@a);
 $answer_string=~s/\/1$//; # remove denominator of 1

# invert a/b to get b/a
sub invert_fraction
{die "More than 2 arguments "   if @_>2;

my @fraction=generate_fraction($_[0]) if @_==1;
 @fraction=@_ if @_==2;
 die "Numerator is zero -- cannot invert " if $fraction[0]==0;
 die "Error Division by zero " if $fraction[1]==0; ## optional?
 if($fraction[0]=~m/\-/)
  {$fraction[0]=abs($fraction[0]);
   $fraction[1]="-$fraction[1]";}

## Last few lines allow for overloading return values
  #-- undefined context -- return nothing
  return if ( ! defined wantarray );
  #-- list/array context -- return array
  return reverse(@fraction) if ( wantarray );
  #-- neither undefined nor list context, return scalar
  return join("/",reverse(@fraction));
}

# input a fraction like a/b and find rationalized equivalent of sqrt(a/b)
# eg sqrt(1/2)=sqrt(2)/2 or sqrt(8/7)=(2*sqrt(14))/7
sub sqrt_of_fraction
{
 my ($exp,$print)=@_ if @_==2;
 $exp=$_[0] if @_==1;
 $print=0 unless $print;
 #$print=1;
 $exp=reduce($exp);
 my @fraction=generate_fraction($exp);
 if($fraction[1]==1)
  {my $temp=simplify_square_root($exp);
   return $temp;}

my $sq_exp="sqrt($fraction[0])/sqrt($fraction[1])";
 my $rationalized_denominator_exp=rationalize_denominator($sq_exp,0);
 my @radicands=$rationalized_denominator_exp=~m/sqrt$(.*?)$/g;
 my $product=$radicands[0]*$radicands[1];
 my $new_num=simplify_square_root($product);

if($new_num!~m/sqrt/)
  {my $temp=reduce($new_num,$fraction[1]);
   return $temp;}
 my ($outer_coefficient,$new_radicand)=$new_num=~m/^(\d+)?\*?sqrt$(.*?)$/;
 $outer_coefficient=1 if $new_num=~m/^sqrt$(.*?)$/;
 $outer_coefficient=-1 if $new_num=~m/^\-sqrt$(.*?)$/;
 #$new_radicand=$1 if $new_num=~m/^sqrt$(.*?)$/;
 my ($reduced_num,$reduced_denom)=reduce($outer_coefficient,$fraction[1]);
 my $ans="($reduced_num*sqrt($new_radicand))/$reduced_denom";
 $ans=~s/$1\*(.*?)$\//$1\//;
 print "

{{{sqrt($exp)}}} Start with the given expression

{{{$sq_exp}}} Break up the expression

{{{($sq_exp)(sqrt($fraction[1])/sqrt($fraction[1]))}}} Multiply the fraction by {{{sqrt($fraction[1])/sqrt($fraction[1])

{{{$rationalized_denominator_exp}}} Combine the expressions and multiply

{{{sqrt($product)/$fraction[1]}}} Combine and multiply the terms in the numerator

{{{($new_num)/$fraction[1]}}} Simplify the numerator

{{{$ans}}} Reduce

" if $print==1;

return $ans;

}
#my $exp="8/7";
#my $ans=sqrt_of_fraction($exp,1);
#print "ANS: {{{sqrt($exp)=$ans}}} ";

## main subroutine - Enter strings for operands and operator .
## Ex: rational_arithmetic(2,"2/3","+")
## or  rational_arithmetic($num1,"@array","/")

sub rat {
 my $arg_count=@_;
 if($arg_count!=3)
   {die "ERROR: You need to enter 3 arguments";
    return;}
 my $operator=pop; # pull last element off of input array @_

if(($_[0]=~m/\./) or ($_[1]=~m/\./))
 {
   my $ans=evaluate_decimal($_[0],$_[1],$operator);
   return $ans;
 }

my @ans;
 for(my $i=0;$i<@_;$i++)
 {my $temp=$_[$i];
 $temp=~s/\///;
 $temp=~s/\-//g;
 $temp=~s/\s//g;
 if($temp=~m/(\D)/)
 {print "TEMP: $temp ";
 die "ERROR: nonnumerical character \"$1\" ";}
 }

my @a=generate_fraction($_[0]);
 my @b=generate_fraction($_[1]);
 if(($a[1]==0)||($b[1]==0))
 {print "..$a[0]..$a[1]..$b[0]..$b[1].. ";
 die "ERROR: Division by zero";}
 if($operator eq '+')
 {my $lcm=lcm($a[1],$b[1]);
 $a[0]=($lcm/$a[1])*$a[0];
 $b[0]=($lcm/$b[1])*$b[0];
 $a[1]=$b[1]=$lcm;
 @ans=($a[0]+$b[0],$a[1]);
 }
 elsif($operator eq '-')
 {my $lcm=lcm($a[1],$b[1]);
 $a[0]=($lcm/$a[1])*$a[0];
 $b[0]=($lcm/$b[1])*$b[0];
 $a[1]=$b[1]=$lcm;
 @ans=($a[0]-$b[0],$a[1]);
 }
 elsif($operator eq '*')
 {@ans=($a[0]*$b[0],$a[1]*$b[1]);}
 elsif($operator eq '/')
 {@ans=($a[0]*$b[1],$a[1]*$b[0]);}
 elsif($operator eq '^')
 {if($b[1]==1)
 {@ans=($a[0]**$b[0],$a[1]**$b[0]);}
 elsif(($b[0]==1)&&($b[1]==2))
 {my $temp=sqrt_of_fraction(join("/",@a));
 return $temp}
 else
 {die "ERROR: exponent ".join("/",@b)." is a fraction b_1=$b[1]";
 return;}
 }
 else
 {die "ERROR: \"$operator\" is not a valid operator";}

## Last few lines allow for overloading return values
  #-- undefined context -- return nothing
  return if ( ! defined wantarray );
  #-- list/array context -- return array
  return @ans if ( wantarray );
  #-- neither undefined nor list context, return scalar
  return join("/",@ans);
}

# given a number n, subroutine will generate all perfect squares up to n
# eg n=103 ----> perfect squares: 1,4,9,16,25,36,49,64,81,100
sub generate_perfect_squares
{
 my $n=$_[0];
 my $sqrt_n=int(sqrt($n));
 my @ans;
 for(my $i=0;$i<=$sqrt_n;$i++)
 {push(@ans,$i**2);}
 shift(@ans) if $ans[0]==0;
 return @ans;
}

# simplify sqrt(72)=sqrt(36)*sqrt(2)=6*sqrt(2)
sub simplify_square_root
{
 my $number=$_[0];
 my $negative_flag=0;
 if($number=~m/^\-/)
  {$negative_flag=1;
   $number=~s/\-//;}
 my $sq=sqrt($number);
 if($sq!~m/\./)
  {return $sq if $negative_flag==0;
   return "$sq*i" if $negative_flag==1;}
 my @factors=factor_generate($number);

if($negative_flag==0)
  {
   if($factors[0] eq 'prime')
     {return ("1","sqrt($number)") if ( wantarray );
      return "sqrt($number)";}
  }
 else
  {
   if($factors[0] eq 'prime')
     {return ("i","sqrt($number)") if ( wantarray );
      return "i*sqrt($number)";}
  }

my @perfect_squares=generate_perfect_squares($number);
 my @factor;
 for(my $i=0;$i<@perfect_squares;$i++)
 {
 my $temp=$number/$perfect_squares[$i];
 push(@factor,$perfect_squares[$i]) if $temp!~m/\./;
 }
 if(@factor==0)
 {
 if($negative_flag==0)
 {return ("1","sqrt($number)") if ( wantarray );
 return "sqrt($number)";}
 else
 {return ("i","sqrt($number)") if ( wantarray );
 return "i*sqrt($number)";}
 }
 my $factor1=$number/$factor[-1];
 my $factor2=$number/$factor1;
 my $sq_factor1=sqrt($factor1);
 my $sq_factor2=sqrt($factor2);
 if($sq_factor1!~m/\./)
 {$factor1=$sq_factor1;}
 else
 {$factor1="sqrt($factor1)";}
 if($sq_factor2!~m/\./)
 {$factor2=$sq_factor2;}
 else
 {$factor2="sqrt($factor2)";}
 if(($sq_factor1!~m/\./)&&($sq_factor2!~m/\./))
 {my $temp=$factor2*$factor1;
 return $temp if $negative_flag==0;
 return "$temp*i" if $negative_flag==1;
 }

if($negative_flag==1)
 {$factor2.="i";}
 #print " factor2,factor1: $factor2,$factor1 ";
 ## Last few lines allow for overloading return values
 #-- undefined context -- return nothing
 return if ( ! defined wantarray );
 #-- list/array context -- return array
 return ($factor2,$factor1) if ( wantarray );
 #-- neither undefined nor list context, return scalar
 if($negative_flag==0)
 {return "$factor2*$factor1";}
 else
 {return "$factor2*$factor1";}
}

sub factor_generate_OLD
{
 my $number=$_[0];

my ($count,@factors);
 $count=0;
 for(my $i=2;$i<int(sqrt($number))+1;$i++)
 {
 if($number%$i==0)
 {
 $count++;
 push(@factors,$i);
 }
 }
 if($count==0)
 {return "prime";}
 else
 {return @factors;}
}

sub clean
{
 my $exp=$_[0];
 $exp=~s/([a-z])sqrt/$1\*sqrt/g;
 return $exp;
}

sub rationalize_denominator
{
 die "Needs two arguments " if @_!=2;
 my ($exp,$print)=@_;
 my ($num,$denom)=split(/\//,$exp);
 if($denom!~m/sqrt/)
  {warn "Denominator doesn't have square root ";
   return $exp;}

my @root_denom=$denom=~m/(sqrt$.*?$)/g;

my ($temp_num,$temp_denom);
 $temp_num=$temp_denom=join("",@root_denom);
 #for(my $i=0;$i<@root_denom;$i++)
 #{}

my $new_denom=join("",@root_denom);
 $new_denom=~s/sqrt$(.*?)$/$1/g;
 my $ans=clean("($num$temp_num)/($new_denom)");
 #{{{($exp)($temp_num/$temp_denom)}}} Multiply both the numerator and the denominator by {{{$temp_num}}}
 print "

{{{$exp}}} Start with the given expression

{{{",clean("($num$temp_num)/($denom$temp_denom)"),"}}} Multiply both the numerator and the denominator by {{{$temp_num}}}

{{{",clean("($num$temp_num)/($new_denom)"),"}}} Multiply {{{$denom}}} and {{{$temp_denom}}} to get {{{$new_denom}}}

" if $print==1;
 ## Last few lines allow for overloading return values
 #-- undefined context -- return nothing
 return if ( ! defined wantarray );
 #-- list/array context -- return array
 return "$num$temp_num",$new_denom if ( wantarray );
 #-- neither undefined nor list context, return scalar
 return $ans;
}

#sub generate_fraction {
#  my $exp=$_[0];
#  my @array=split(/\//,$exp);
#  $array[1]=1 if @array==1;
#  return @array;
#}

## if one operand has a decimal portion, use this subroutine
sub evaluate_decimal
{
   die "ERROR: You need to enter 3 arguments" if @_!=3;

my @a=generate_fraction($_[0]);
   my @b=generate_fraction($_[1]);
   my $operator=$_[2];

my ($num,$denom);

if($operator eq '+')
   {
      $num=$a[0]*$b[1]+$b[0]*$a[1];
      $denom=$a[1]*$b[1];
   }
   elsif($operator eq '-')
   {
      $num=$a[0]*$b[1]-$b[0]*$a[1];
      $denom=$a[1]*$b[1];
   }
   elsif($operator eq '*')
   {
      $num=$a[0]*$b[0];
      $denom=$a[1]*$b[1];
   }
   elsif($operator eq '/')
   {
      $num=$a[0]*$b[1];
      $denom=$a[1]*$b[0];
   }
   elsif($operator eq '^')
   {
      my $exponent=$b[0]/$b[1];
      $num=$a[0]**$exponent;
      $denom=$a[1]**$exponent;
   }
 else
 {
   die "ERROR: \"$operator\" is not a valid operator";
 }

my $ans=$num/$denom;

return $ans;
}

sub factor_generate
{
 my $number=abs($_[0]);

my ($count,@factors);
 $count=0;
 for(my $i=1;$i<=$number;$i++)
 {
 if($number%$i==0)
 {
 $count++;
 push(@factors,$i);
 }
 }
 if($count==0)
 {return (1,$number);}
 else
 {return @factors;}
}

sub factor_by_grouping_clean
{
 my $exp=$_[0];
 $exp=~s/(\(|^|\+|\-)1([a-z])/$1$2/g;
 $exp=~s/\+\-/\-/g;
 return $exp;
}

## finds the gcf of monomials
sub monomial_gcf
{
  die "Needs 2 argument " if @_!=2;
  my ($exp,$print)=@_;

$exp=","."$exp";
  $exp=~s/,([a-z])/,1 $1/g;
  $exp=~s/,\-([a-z])/,\-1 $1/g;
  $exp=~s/([a-z])([a-z]|$)/$1\^1$2/g;
  $exp=~s/([a-z])$/$1\^1/g;
  $exp=~s/([a-z]),/$1\^1,/g;
  $exp=~s/\s//g;

my @coefficients=$exp=~m/,(\-\d+|\d+)/g;

my ($count,@temp_terms,@final_array);

$exp=~s/^,//;
  my @terms=split(/,/,$exp);
  die "Needs 2 terms " if @terms!=2;
  ## remove duplicates from an array
  sub remove_duplicates {
  my (@arr);
  @arr=@_;

for(my $i=0;$i<@arr;$i++)
 {
 for(my $j=0;$j<@arr;$j++)
 {if($i!=$j)
 {if($arr[$i] eq $arr[$j])
 {splice(@arr,$i,1) if $i>$j;
 splice(@arr,$j,1) if $j>$i;
 }
 }
 }
 }

return @arr;
  }

for my $i ('a'..'z')
 {$count=0;
 for(my $j=0;$j<@terms;$j++)
 {if($terms[$j]=~m/$i/)
 {$count++;}
 }
 if($count==@terms)
 {
 @temp_terms=$exp=~m/($i\^\d+)/g;
 for(my $k=0;$k<@temp_terms;$k++)
 {my $temp=$1 if $temp_terms[0]=~m/\^(\d+)/;
 my $temp1=$1 if $temp_terms[1]=~m/\^(\d+)/;
 if($temp<=$temp1)
 {push(@final_array,$temp_terms[0]);}
 else
 {push(@final_array,$temp_terms[1]);}
 }
 }
 }

@final_array=remove_duplicates(@final_array);

my $num_gcf=multigcf(@coefficients);
  $num_gcf=abs($num_gcf);

my $final_gcf="$num_gcf ".join("",@final_array)."";
  $final_gcf=~s/\s//g;
  $final_gcf=~s/\^1($|\D)/$1/g;

return $final_gcf;

}

# find and extract monomial coefficient .... NEW
sub monomial_coefficient
{
 my $exp=$_[0];
 my $coefficient;
 if($exp=~m/[a-z]/)
 {
 $coefficient=-1 if $exp=~m/^\-/;
 $coefficient="$1" if $exp=~m/^(\-?\d+\/\d+|\-?\d+\.\d+|\-?\d+)[a-z]/;
 $coefficient=1 unless $coefficient;
 }
 else
 {$coefficient=$exp;}
 #print "Coefficient for $exp is : $coefficient ";
 return $coefficient;
}

sub rewrite_fraction
{
 my $exp=$_[0];
 $exp=~s/$|$//g;
 my $coefficient=monomial_coefficient($exp);
 #my $var=$1 if $exp=~m/
 my $temp=$exp;
 $temp=~s/^$coefficient// if $coefficient;
 if($exp=~m/\/(\-?\d+)/)
 {$coefficient.="/$1" if $coefficient!~m/\//;
 $temp=~s/\/(\-?\d+)//;}
 $temp=~s/^\-//;
 my $ans="($coefficient)$temp";
 $ans=~s/$(\-?\d+\.\d+|\-?\d+)$/$1/;
 $ans=~s/^1([a-z])/$1/;
 #print "$coefficient $exp = $ans ";
 return $ans;

}
#rewrite_fraction("(5/3)xz^2y");

#my $exp="-10";
#my $ans=monomial_coefficient($exp);
#print " ANS: $ans ";

# find and extract monomial exponents
sub monomial_exponent
{
 my $exp=$_[0];
 my $exponent_hash_ref;
 my %hash;
 for my $i ('a'..'z')
 {
 if($exp=~m/$i/)
 {#print "i=$i ";
 $exponent_hash_ref->{$i}=$1 if $exp=~m/$i\^$?(\-?\d+)$?/;
 #$exponent_hash_ref->{$i}=1 if $exp=~m/$i(\w+|\)|$)/;
 $exponent_hash_ref->{$i}=1 if $exp!~m/$i\^/;
 #$hash{$i}=$1 if $exp=~m/$i\^(\d+)/;
 #$hash{$i}=1 if $exp=~m/$i[^\^]/;
 }
 }
 #print "EXP123: $exponent_hash_ref->{'y'}";
 return $exponent_hash_ref;

}
#my $exp1="5x^15";
#my $ans2=monomial_exponent($exp1);
#my %temp=%$ans2;
#print " ANS: $ans2->{'x'} ";

#input format: 2 strings of arguments and print argument
sub monomial_multiplication
{
 die "Needs 3 arguments " if @_!=3;
 my $print=pop;
 my @monomials=@_;
 my $final_coefficient;

# extract coefficients
 my $coefficient1=monomial_coefficient($monomials[0]);
 my $coefficient2=monomial_coefficient($monomials[1]);

# multiply coefficients
 if(($coefficient1!~m/\./)&&($coefficient2!~m/\./))
  {$final_coefficient=reduce(rat($coefficient1,$coefficient2,"*"));}
 else
  {
   #$final_coefficient=eval("$coefficient1*$coefficient2");
    $final_coefficient=$coefficient1*$coefficient2;
  }

# extract exponents
 my $exp_hash_ref1=monomial_exponent($monomials[0]);
 my $exp_hash_ref2=monomial_exponent($monomials[1]);
 my ($final_exp_hash_ref,$final_var);
 my @temp_monomials=@monomials;
 @temp_monomials=map{s/^\-?\d+\.\d+|^\-?\d+//;$_} @temp_monomials;
 my $display="$final_coefficient@temp_monomials";
 $display=~s/(\d+)\/(\d+)/$$1\/$2$/g;
 print " {{{$final_coefficient@temp_monomials}}} Multiply the coefficients {{{$coefficient1}}} and {{{$coefficient2}}} to get {{{$final_coefficient}}} " if $print==1;

#if monomials DONT contain a variable
 if(($monomials[0]!~m/[a-z]/)&&($monomials[1]!~m/[a-z]/))
  {
   return $final_coefficient;
  }

my ($int_exp_hash,$intermediate);
 # add exponents
 for my $i ('a'..'z')
  {
    unless(exists $exp_hash_ref1->{$i})
     {$exp_hash_ref1->{$i}=0;}
    unless(exists $exp_hash_ref2->{$i})
     {$exp_hash_ref2->{$i}=0;}
   $final_exp_hash_ref->{$i}=$exp_hash_ref1->{$i}+$exp_hash_ref2->{$i};

if(($exp_hash_ref1->{$i}!=0)&&($exp_hash_ref2->{$i}!=0))
 {
 $int_exp_hash->{$i}="$i^($exp_hash_ref1->{$i}+$exp_hash_ref2->{$i})";
 #print "i=$i $i^($exp_hash_ref1->{$i}+$exp_hash_ref2->{$i}) ";
 $intermediate.=$int_exp_hash->{$i};
 }
# else
# {

$final_var.="$i^$final_exp_hash_ref->{$i}" if $final_exp_hash_ref->{$i}!=0;
   $final_var=~s/\^1$// if($final_var);
  }

if(($monomials[0]=~m/[a-z]/)&&($monomials[1]=~m/[a-z]/))
 {
 $display="$final_coefficient$intermediate";
 $display=~s/(\d+)\/(\d+)/$$1\/$2$/g;
 print " {{{$display}}} When you multiply monomials, simply add the exponents. " if $print==1;
 }

$final_var="" unless($final_var);
 $final_coefficient=1 unless($final_coefficient);
 my $ans="$final_coefficient$final_var";
 $ans=~s/^1([a-z])/$1/g;
 if(($monomials[0]=~m/[a-z]/)&&($monomials[1]=~m/[a-z]/))
 {print " {{{$ans}}} Add. " if $print==1;}
 ## Last few lines allow for overloading return values
 #-- undefined context -- return nothing
 return if ( ! defined wantarray );
 #-- list/array context -- return array
 return ($final_coefficient,$final_var) if ( wantarray );
 #-- neither undefined nor list context, return scalar
 return $ans;

}
#my @exp=qw(1 xy);
#my $ans1=monomial_multiplication(@exp,1);
#print " ($exp[0])*($exp[1])=$ans1 ";

#input format: 2 strings of arguments and print argument
sub monomial_division
{
 die "Needs 3 arguments " if @_!=3;
 my $print=pop;
 my @monomials=@_;
 my $final_coefficient;

# extract coefficients
 my $coefficient1=monomial_coefficient($monomials[0]);
 my $coefficient2=monomial_coefficient($monomials[1]);

# divide coefficients
 if(($coefficient1!~m/\./)&&($coefficient2!~m/\./))
  {$final_coefficient=reduce(rat($coefficient1,$coefficient2,"/"));}
 else
  {
   #$final_coefficient=eval("$coefficient1/$coefficient2");
    $final_coefficient=$coefficient1/$coefficient2;
  }

# extract exponents
 my $exp_hash_ref1=monomial_exponent($monomials[0]);
 my $exp_hash_ref2=monomial_exponent($monomials[1]);
 my ($final_exp_hash_ref,$final_var);

my @temp_monomials=@monomials;
 @temp_monomials=map{s/^\-?\d+//;$_} @temp_monomials;
 my $display="$final_coefficient@temp_monomials";
 $display=~s/(\d+)\/(\d+)/$$1\/$2$/g;
 print " {{{$display}}} Divide the coefficients {{{$coefficient1}}} and {{{$coefficient2}}} to get {{{$final_coefficient}}} " if $print==1;

#if monomials DONT contain a variable
 if(($monomials[0]!~m/[a-z]/)&&($monomials[1]!~m/[a-z]/))
  {
   return $final_coefficient;
  }

my ($int_exp_hash,$intermediate);
 # subtract exponents
 for my $i ('a'..'z')
  {
    unless(exists $exp_hash_ref1->{$i})
     {$exp_hash_ref1->{$i}=0;}
    unless(exists $exp_hash_ref2->{$i})
     {$exp_hash_ref2->{$i}=0;}
   $final_exp_hash_ref->{$i}=$exp_hash_ref1->{$i}-$exp_hash_ref2->{$i};

if(($exp_hash_ref1->{$i}!=0)&&($exp_hash_ref2->{$i}!=0))
    {$int_exp_hash->{$i}="$i^($exp_hash_ref1->{$i}-$exp_hash_ref2->{$i})";
     $intermediate.=$int_exp_hash->{$i};}

$final_var.="$i^$final_exp_hash_ref->{$i}" if $final_exp_hash_ref->{$i}!=0;
   $final_var=~s/\^1$// if($final_var);
  }

if(($monomials[0]=~m/[a-z]/)&&($monomials[1]=~m/[a-z]/))
 {
 $display="$final_coefficient$intermediate";
 $display=~s/(\d+)\/(\d+)/$$1\/$2$/g;
 print " {{{$display}}} When you divide monomials, simply subtract the exponents. " if $print==1;
 }

$final_var="" unless($final_var);
 $final_coefficient=1 unless($final_coefficient);
 my $ans="$final_coefficient$final_var";
 $ans=~s/^1([a-z])/$1/g;
 $ans=~s/^(\-?\d+)\/(\d+)([a-z])/($1\/$2)$3/;
 $ans=~s/^$\-/\-\(/;
 $ans=~s/\^\-(\d+)/\^(\-$1$/g;
 if(($monomials[0]=~m/[a-z]/)&&($monomials[1]=~m/[a-z]/))
 {print " {{{$ans}}} Subtract. " if $print==1;}

## Last few lines allow for overloading return values
 #-- undefined context -- return nothing
 return if ( ! defined wantarray );
 #-- list/array context -- return array
 return ($final_coefficient,$final_var) if ( wantarray );
 #-- neither undefined nor list context, return scalar
 return $ans;

}

#my @exp=qw(-2x^2 4x^5yz);
#my $ans1=monomial_division(@exp,1);
#print " ($exp[0])/($exp[1])=$ans1 ";

#input format: 2 strings of arguments and print argument
sub monomial_exponentiation
{
 die "Needs 3 arguments " if @_!=3;
 my $print=pop;
 my @monomials=@_;
 die "Variable in exponent " if $monomials[1]=~m/[a-z]/;
 my $coefficient=monomial_coefficient($monomials[0]);
 my ($final_exp_hash_ref,$final_var);
 $coefficient=reduce(rat($coefficient,$monomials[1],"^"));

my $exp_hash_ref1=monomial_exponent($monomials[0]);
 # multiply exponents
 for my $i ('a'..'z')
  {
    unless(exists $exp_hash_ref1->{$i})
     {$exp_hash_ref1->{$i}=0;}

$final_exp_hash_ref->{$i}=reduce(rat($monomials[1],$exp_hash_ref1->{$i},"*"));
 $final_var.="$i^$final_exp_hash_ref->{$i}" if $final_exp_hash_ref->{$i}!=0;
 $final_var=~s/\^1$// if($final_var);
 }
 my $ans="$coefficient$final_var";
 $ans=~s/(\d+)\/(\d+)([a-z])/$$1\/$2$$3/g;
 #print "$ans ";
 return $ans;
}

#my @exp=qw(3x^2yz^3 3);
#my $ans3=monomial_exponentiation(@exp,1);
#print " {{{($exp[0])^($exp[1])=$ans3}}} ";

sub simplify_negative_exponents
{
 die "Needs 2 arguments " if @_!=2;
 my ($exp,$print)=@_;
 #my $coefficient=$1 if $exp=~m/(\-?\d+\/\d+|\-?\d+\.\d+|\d+)[a-z]/;
 #$coefficient=1 unless $coefficient;
 my $coefficient=monomial_coefficient($exp);
 my @coefficient=generate_fraction($coefficient);
 my $exp_hash_ref=monomial_exponent($exp);
 my ($num,$denom);
 for my $i ('a'..'z')
 {
 unless(exists $exp_hash_ref->{$i})
 {$exp_hash_ref->{$i}=0;}
 if($exp_hash_ref->{$i}<0)
 {
 my $abs=$exp_hash_ref->{$i};
 $abs=~s/\-//;
 $denom.="$i^$abs";
 }
 else
 {$num.="$i^$exp_hash_ref->{$i}" if $exp_hash_ref->{$i}!=0;}
 }print "... @coefficient ... ";
 $num=1 unless $num;
 $denom=1 unless $denom;
 return ("$coefficient[0]?$num","$coefficient[1]?$denom");
}

# format 2 input strings and an operator (only * and / for now)
sub monomial_arithmetic
{
 die "Needs 4 arguments " if @_!=4;
 my $print=pop;
 my $op=pop;
 my @arguments=@_;
 my $ans;

for(my $i=0;$i<@arguments;$i++)
 {$arguments[$i]=rewrite_fraction($arguments[$i]);}
 @arguments=map{s/$|$//g;$_} @arguments;
 print " {{{(".join(")$op(",@arguments).")}}} Start with the given expression. " if $print==1;
 if($op eq '*')
 {$ans=monomial_multiplication(@arguments,$print);}
 elsif($op eq '/')
 {$ans=monomial_division(@arguments,$print);}
 elsif($op eq '^')
 {$ans=monomial_exponentiation(@arguments,$print);}
 else
 {die "Invalid operator \"$op\" ";}
 #print "{{{(".join(")$op(",@arguments).")=$ans}}} ";
 return $ans;
}

sub factor_by_grouping
{
 die " Needs 3 arguments" if @_!=3;
 my ($exp,$show,$print)=@_;
 print " {{{$exp}}} Start with the given expression. " if $print==1 && $show==1;
 my @terms=generate_terms($exp);
 my @coefficients=multivariate_coefficient($exp);
 die "Needs 4 terms " if @terms!=4;
 my $display=factor_by_grouping_clean("($terms[0]+$terms[1])+($terms[2]+$terms[3])");
 print " {{{$display}}} Group the terms into two pairs. " if $print==1;
 my @new_terms;

my $gcf1=monomial_gcf("$terms[0],$terms[1]",0);
  my $disp_gcf=factor_by_grouping_clean("$gcf1");
  $new_terms[0]=monomial_arithmetic($terms[0],$gcf1,"/",0);
  $new_terms[1]=monomial_arithmetic($terms[1],$gcf1,"/",0);

$display=factor_by_grouping_clean("$gcf1($new_terms[0]+$new_terms[1])+($terms[2]+$terms[3])");

print " {{{$display}}} Factor out the GCF {{{$disp_gcf}}} from the first group. " if $print==1;

my $gcf2=monomial_gcf("$terms[2],$terms[3]",0);
  $disp_gcf=factor_by_grouping_clean("$gcf2");
  $gcf2=reduce(rat(-1,$gcf2,"*")) if $terms[2]=~/\-/;
  $new_terms[2]=monomial_arithmetic($terms[2],$gcf2,"/",0);
  $new_terms[3]=monomial_arithmetic($terms[3],$gcf2,"/",0);

$display=factor_by_grouping_clean("$gcf1($new_terms[0]+$new_terms[1])+$gcf2($new_terms[2]+$new_terms[3])");
 print " {{{$display}}} Factor out {{{$disp_gcf}}} from the second group. The goal of this step is to make the terms in the second parenthesis equal to the terms in the first parenthesis. " if $print==1;

if("$new_terms[0]+$new_terms[1]" eq "$new_terms[2]+$new_terms[3]")
 {
 $display=factor_by_grouping_clean("($gcf1+$gcf2)($new_terms[0]+$new_terms[1])");
 my $disp_combined=factor_by_grouping_clean("$new_terms[0]+$new_terms[1]");
 print " {{{$display}}} Combine like terms. Or factor out the common term {{{$disp_combined}}} " if $print==1;

}
  my $factor1=factor_by_grouping_clean("$gcf1+$gcf2");
  my $factor2=factor_by_grouping_clean("$new_terms[0]+$new_terms[1]");

return ($factor1,$factor2);
}

sub factor_quadratic_clean
{
 my $exp=$_[0];
 $exp=~s/(\(|^|\+|\-)1([a-z])/$1$2/g;
 $exp=~s/\+\-/\-/g;
 return $exp;
}

sub factor_quadratic
{
  die " Needs 3 arguments" if @_!=3;
  my ($exp,$show,$print)=@_;
  $exp=~s/\s//g;
  $exp=~tr/[A-Z]/[a-z]/;
  $exp=~s/([a-z])(\d+)/$1\^$2/g;

die "Cannot support fractions yet..." if $exp=~m/\//;

#print " {{{$exp}}} Start with the given expression. " if $print==1 && $show==1;

my @terms=generate_terms($exp);
  my $unique_var_count=0;
  my @coefficients;
  my ($a,$b,$c,$last_coefficient_note);
  for my $i ('a'..'z')
   {
    $unique_var_count++ if $exp=~m/$i/;
   }
  die "There are no variables? " if $unique_var_count==0;

if($unique_var_count==1)
 {
 my $var=$1 if $exp=~m/([a-z])/;
 @coefficients=univariate_coefficient($exp);
 ($a,$b,$c)=@coefficients;
 #print " Since the expression {{{$exp}}} is in form of {{{a$var^2+b$var+c}}}, we can see that {{{a=$a}}}, {{{b=$b}}}, and {{{c=$c}}}. " if $print==1;
 if($terms[2]=~m/[a-z]/)
 {$last_coefficient_note="the last coefficient";}
 else
 {$last_coefficient_note="the last term";}
 #print " Looking at the expression {{{$exp}}}, we can see that the first coefficient is {{{$a}}}, the second coefficient is {{{$b}}}, and $last_coefficient_note is {{{$c}}}. " if $print==1;
 }
 if($unique_var_count>1)
 {
 $last_coefficient_note="the last coefficient"; ### not sure about this line????

@coefficients=multivariate_coefficient($exp);
 ($a,$b,$c)=@coefficients;
 #print " @coefficients ";
 #die "NEED TO WORK ON THIS SECTION....";
 }

print " Looking at the expression {{{$exp}}}, we can see that the first coefficient is {{{$a}}}, the second coefficient is {{{$b}}}, and $last_coefficient_note is {{{$c}}}. " if $print==1;

#die "There are more than 3 terms " if @coefficients>3;
  #die "There are more than 3 terms " if @coefficients>3;
  #die "Why factor when there's only one term? " if @coefficients==1;
  die "There need to be 3 terms " if @coefficients!=3;

my $ac=reduce(rat($a,$c,"*"));

print " Now multiply the first coefficient {{{$a}}} by $last_coefficient_note {{{$c}}} to get {{{($a)($c)=$ac}}}. " if $print==1;

#So this means that {{{ac=$ac}}} " if $print==1;

print " Now the question is: what two whole numbers multiply to {{{$ac}}} (the previous product) and add to the second coefficient {{{$b}}}? " if $print==1;

print " To find these two numbers, we need to list all of the factors of {{{$ac}}} (the previous product). " if $print==1;

my @ac_factors=factor_generate($ac);
  #my @neg_ac_factors=@ac_factors;
  my @neg_ac_factors=map("-$_",@ac_factors);

my @reversed_ac_factors=reverse(@ac_factors);
  my @reversed_neg_ac_factors=reverse(@neg_ac_factors);

my @addends;

print " Factors of {{{$ac}}}: ".join(",",@ac_factors)." ".join(",",@neg_ac_factors)." " if $print==1;

print " Note: list the negative of each factor. This will allow us to find all possible combinations. " if $print==1;

#if(@ac_factors==1)
 #{
 print " These factors pair up and multiply to {{{$ac}}}. " if $print==1;

##For instance, {{{$ac_factors[0]*$reversed_ac_factors[0]=$ac}}}. " if $print==1;

#}
# else
# {
# print " These factors pair up and multiply to {{{$ac}}}. For instance, {{{$ac_factors[0]*$reversed_ac_factors[0]=$ac}}}, {{{$ac_factors[1]*$reversed_ac_factors[1]=$ac}}}, etc. " if $print==1;
# }

#print " Note:" if $print==1;

if($ac=~m/\-/)
 {
# for (my $i=0;$i<@ac_factors;$i++)
# {
#
# }
# for (my $i=0;$i<@ac_factors;$i++)
# {
#
# }

#print " Since {{{$ac}}} is negative, this means that one factor is positive and one is negative. " if $print==1;
 ## pos then neg
 for (my $i=0;$i<@ac_factors/2;$i++)
 {
 print "$ac_factors[$i]*($reversed_neg_ac_factors[$i]) = $ac " if $print==1;
 push(@addends,"$ac_factors[$i],$reversed_neg_ac_factors[$i]");
 }
 ## neg then pos
 for (my $i=0;$i<@ac_factors/2;$i++)
 {
 print "($neg_ac_factors[$i])*($reversed_ac_factors[$i]) = $ac " if $print==1;
 push(@addends,"$neg_ac_factors[$i],$reversed_ac_factors[$i]");
 }
 }
 else
 {

for (my $i=0;$i<@ac_factors;$i++)
 {

}
 for (my $i=0;$i<@ac_factors;$i++)
 {

}
 #print " Since {{{$ac}}} is positive, this means that either a) both factors are positive, or... b) both factors are negative. " if $print==1;

## both pos
 for (my $i=0;$i<@ac_factors/2;$i++)
 {
 print "$ac_factors[$i]*$reversed_ac_factors[$i] = $ac " if $print==1;
 push(@addends,"$ac_factors[$i],$reversed_ac_factors[$i]");
 }
 ## both neg
 for (my $i=0;$i<@ac_factors/2;$i++)
 {
 print "($neg_ac_factors[$i])*($reversed_neg_ac_factors[$i]) = $ac " if $print==1;
 push(@addends,"$neg_ac_factors[$i],$reversed_neg_ac_factors[$i]");
 }
 }

print " Now let's add up each pair of factors to see if one pair adds to the middle coefficient {{{$b}}}: " if $print==1;

my ($num1,$num2);

print " <table border=\"1\">" if $print==1;
print "<th>First Number</th><th>Second Number</th><th>Sum</th>" if $print==1;
 for (my $i=0;$i<@addends;$i++)
 {
 my ($addend1,$addend2)=split(/,/,$addends[$i]);
 my $sum_string="$addend1+$addend2";
 my $sum_num=reduce(rat($addend1,$addend2,"+"));
 $sum_string=~s/\+\-(.*?)$/\+$\-$1$/;
 my $color="";
 if($sum_num eq $b)
 {
 $num1=$addend1;
 $num2=$addend2;
 $color="red";
 }
 else
 {
 $color="black";
 }

print "<tr><td align=\"center\">$addend1</td><td align=\"center\">$addend2</td><td align=\"center\">$sum_string=$sum_num</td></tr>" if $print==1;

}
 print "</table> " if $print==1;

if((length($num1)==0)||(length($num2)==0))
 {
 print " From the table, we can see that there are no pairs of numbers which add to {{{$b}}}. So {{{$exp}}} cannot be factored. " if $print==1;
 return if ( ! defined wantarray );
 #-- list/array context -- return array
 return (0,0) if ( wantarray );
 #-- neither undefined nor list context, return scalar
 #return "($factor1)($factor2)";
 }

print " From the table, we can see that the two numbers {{{$num1}}} and {{{$num2}}} add to {{{$b}}} (the middle coefficient). " if $print==1;

print " So the two numbers {{{$num1}}} and {{{$num2}}} both multiply to {{{$ac}}} and add to {{{$b}}} " if $print==1;

my $inner_terms_var=$1 if $terms[1]=~m/\d+(.*?)$/;
 my $disp_middle=factor_quadratic_clean("$num1$inner_terms_var+$num2$inner_terms_var");
 print " Now replace the middle term {{{$terms[1]}}} with {{{$disp_middle}}}. Remember, {{{$num1}}} and {{{$num2}}} add to {{{$b}}}. So this shows us that {{{$disp_middle=$terms[1]}}}. " if $print==1;

my $display=factor_quadratic_clean("$terms[0]+highlight($num1$inner_terms_var+$num2$inner_terms_var)+$terms[2]");
 print " {{{$display}}} Replace the second term {{{$terms[1]}}} with {{{$disp_middle}}}. " if $print==1;

my ($factor1,$factor2)=factor_by_grouping("$terms[0]+$num1$inner_terms_var+$num2$inner_terms_var+$terms[2]",0,$print);
 #$display=factor_quadratic_clean("($terms[0]+$num1$inner_terms_var)+($num2$inner_terms_var+$terms[2]");
 #print " {{{$display}}} Group the terms into two pairs of groups. " if $print==1;

if($show==1)
 {
 print " --------------------------------------------- " if $print==1;
 print " Answer: " if $print==1;
 print " So {{{$exp}}} factors to {{{($factor1)($factor2)}}}. " if $print==1;
 print " Note: you can check the answer by FOILing {{{($factor1)($factor2)}}} to get {{{$exp}}} or by graphing the original expression and the answer (the two graphs should be identical). " if $print==1;
 }

return if ( ! defined wantarray );
 #-- list/array context -- return array
 return ($factor1,$factor2) if ( wantarray );
 #-- neither undefined nor list context, return scalar
 return "($factor1)($factor2)";
}

## extract coefficients from univariate polynomials (one variable)
## eg 2x^2+1/3x+2 ---> 2, 1/3, 2
## Terms need to be ordered first!!!
sub univariate_coefficient
{
  my $expression=$_[0];
  $expression=~s/\-/\+\-/g;                      # change each - into +-
  $expression=~s/^\+//;                          # remove first +
  $expression=~s/([a-z])(\+|\-)/$1\^1$2/g;       # replace 5x with 5x^1
  $expression=~s/([a-z])$/$1\^1/g;               # replace 5x with 5x^1
  $expression=~s/(\+|\-)([a-z])/$1 1 $2/g;       # replace +x with +1x
  $expression=~s/^([a-z])/1 $1/g;                # replace +x with +1x
  $expression=~s/\s//g;
  my $degree=$1 if $expression=~m/\^(\d+)/;
  my @terms=split(/\+/,$expression);
  my $inc=0;
  my @coefficients;
  for(my $i=$degree;$i>0;$i--)
   {if($terms[$inc]=~m/^(.*?)[a-z]\^$i$/)
      {push(@coefficients,$1);
       $inc++;}
    else
      {push(@coefficients,0);}
   }
  if($terms[-1]!~m/[a-z]/)
    {push(@coefficients,$terms[-1]);}
  else
    {push(@coefficients,0);}

return @coefficients;
}

sub factor_out_gcf
{
 my $exp=$_[0];
 $exp=~s/([a-z])([a-z]|\+|\-|$)/$1\^1$2/g;
 $exp=~s/\*//g;
 my @coefficients=multivariate_coefficient($exp);
 my $num_gcf=multigcf(@coefficients);
 my @terms=generate_terms($exp);
 my (@var_gcf,$count,@inner);
 $count=0;

for my $i('a'..'z')
 {$count=0;
 for(my $j=0;$j<@terms;$j++)
 {$count++ if $terms[$j]=~m/$i/;}
 if($count==@terms)
 {my @temp_array=$exp=~m/$i\^(\d+)/g; ## extract all exponents
 @temp_array=my_sort(@temp_array); ## sort exponents in ascending order
 my $other_temp1728 = shift(@temp_array);
 push(@var_gcf,"$i^$other_temp1728"); ## add lowest term to var_gcf
 }
 }
 my $gcf="$num_gcf".join("",@var_gcf);
 $gcf=~s/^\-//;
 # if $exp!~m/^\-/;
 $gcf="-$gcf" if $exp=~m/^\-/;
 $gcf=~s/\-\-/\+/g;
 $gcf=~s/^\+//;
 for(my $i=0;$i<@terms;$i++)
 {push(@inner,monomial_mult_div($terms[$i],$gcf,"/"));}
 for(my $i=0;$i<@inner;$i++)
 {$inner[$i]=~s/[a-z]\^0(?=[a-z]|$)/$1/g;
 $inner[$i]=1 unless($inner[$i]);}

@inner=map{s/([a-z])\^1(?=[a-z]|$)/$1$2/g;$_} @inner;
 my $inner=join("+",@inner);
 $inner=~s/\+\-/\-/g;

$gcf=~s/\^1(\+|\-|$)/$1/g;
 $gcf=~s/^1([a-z])/$1/g;
 ## Last few lines allow for overloading return values
 #-- undefined context -- return nothing
 return if ( ! defined wantarray );
 #-- list/array context -- return array
 return ($gcf,$inner) if ( wantarray );
 #-- neither undefined nor list context, return scalar
 return "$gcf($inner)";
}

sub factor_quadratic_gcf
{
   my ($exp,$show,$print)=@_;
   my ($gcf,$inner)=factor_out_gcf($exp);
   my $step2="$gcf($inner)";
   $step2=~s/^\-1\(/\-\(/;

die "Expression \"$exp\" needs to have exponents" if $exp!~m/\^/;

#print " <a name=\"top\"> ";
 #print " <a href=\"#ans\">Jump to Answer</a> ";

if($gcf!=1)
 {
 print " {{{$exp}}} Start with the given expression. " if $print==1;
 print " {{{$step2}}} Factor out the GCF {{{$gcf}}}. " if $print==1;
 print " Now let's try to factor the inner expression {{{$inner}}} " if $print==1;
 print " --------------------------------------------------------------- " if $print==1;
 }

#print " Looking at the expression {{{$inner}}}, we can see that the first coefficient is {{{$a}}}, the second coefficient is {{{$b}}}, and $last_coefficient_note is {{{$c}}}. " if $print==1;
# else
# {
# $inner=
# }
 my ($factor1,$factor2)=factor_quadratic($inner,0,1);
 my $answer="";
 if($factor1 eq '0' and $factor2 eq '0')
 {
 #print "$factor1, $factor2 TEST!!!";
 $answer="$inner" if $gcf!=1;
 print " =============================================================== " if $print==1;
 print " <a name=\"ans\"> ";

print " Answer: " if $print==1;
 if($gcf!=1)
 {
 $answer="$gcf($inner)" if $gcf!=1;
 $answer=~s/^\-1\(/\-\(/;
 print " So {{{$exp}}} simply factors to {{{$answer}}} ";
 print " In other words, {{{$exp=$answer}}}. " if $print==1;
 #print " <a href=\"#top\">Jump to Top</a> ";
 }
 else
 { $answer=0;
 print " So {{{$exp}}} doesn't factor at all (over the rational numbers). ";
 print " So {{{$exp}}} is prime. ";
 #print " <a href=\"#top\">Jump to Top</a> ";
 }
 return $answer;
 }

if($gcf==-1)
   {
      $answer="-($factor1)($factor2)";
   }
   elsif($gcf!=1)
   {
      $answer="$gcf($factor1)($factor2)";
   }
   else
   {
      $answer="($factor1)($factor2)";
   }

if($gcf!=1)
  {

if($factor1 eq $factor2)
 {
 print " {{{($factor1)^2}}} Condense the terms. " if $print==1;
 $answer="$gcf($factor1)^2";
 }

print " -------------------------------------------------- " if $print==1;
 print " So {{{$gcf($inner)}}} then factors further to {{{$answer}}} " if $print==1;
 }
 else
 {
 if($factor1 eq $factor2)
 {
 print " {{{($factor1)^2}}} Condense the terms. " if $print==1;
 $answer="($factor1)^2";
 }
 }

if($show==1)
 {
 my $note=" completely" if $gcf!=1;
 $note="" if $gcf==1;
 print " =============================================================== " if $print==1;
 #print " <a name=\"ans\"> ";
 print " Answer: " if $print==1;
 print " So {{{$exp}}}$note factors to {{{$answer}}}. " if $print==1;
 print " In other words, {{{$exp=$answer}}}. " if $print==1;

print " Note: you can check the answer by expanding {{{$answer}}} to get {{{$exp}}} or by graphing the original expression and the answer (the two graphs should be identical). " if $print==1;
 }

#print " <a href=\"#top\">Jump to Top</a> ";

return $answer;

}

END:

==section output

==section check