Solver Finding the Determinant of a 2x2 Matrix

Source code of 'Finding the Determinant of a 2x2 Matrix'

This Solver (Finding the Determinant of a 2x2 Matrix) 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
This solver will show you how to find the determinant of any 2x2 matrix

Enter the individual entries of the matrix (enter numbers only):
<table frame="vsides">
<tr><td>*[input my_a=1]</td><td>*[input my_b=2]</td></tr>
<tr><td>*[input my_c=3]</td><td>*[input my_d=4]</td> </tr>
</table>

==section solution

perl

## --------------------------- Subroutines ------------------------------------------

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_up("($num$temp_num)/($new_denom)");

## 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 clean {
 my $exp=$_[0];
 $exp=~s/\+\-/\-/g;
 $exp=~s/\-\-/\+/g;
 $exp=~s/(\D)$(\-?\d+)$(\D)/$1$2$3/g;
 return $exp;
 }

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

sub convert_to_latex
{
  my $exp=$_[0];
  my @fraction=generate_fraction($exp);
  my $ans="\\frac{$fraction[0]}{$fraction[1]}" if $fraction[1]!=1;
  $ans="$exp" if $fraction[1]==1;
  $ans=~s/^(\\frac\{)\-/\-$1/;
  return $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 \n\n";
 ## 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
{
 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 gcf {
  my ($x, $y) = @_;
  ($x, $y) = ($y, $x % $y) while $y;
  return $x;
}

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{
 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[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]==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;
}

# 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;
 $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\//;

return $ans;

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

## 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\n";
 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]..\n";
    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);
}

#format: input expression and list of characters that are deemed safe. If it finds any nonword character, it will return 1 for error
# input: 2 strings
# output:
sub check_for_illegal_characters
{
 die "Needs 3 arguments " if @_!=3;
 my ($exp,$safe_chars,$flag)=@_; ##note: flag =1 words allowed flag=0 only numeric characters allowed
 $exp=~s/\s//g;
 my @safe_chars=split(/,/,$safe_chars);
 @safe_chars=map(quotemeta($_),@safe_chars);
 my (@illegal_chars,$illegal_chars_string);
 for(my $i=0;$i<@safe_chars;$i++)
 {$exp=~s/$safe_chars[$i]//g;}
 my $regexp="\\W+" if $flag==1; # pick out any non-word chars
 $regexp="\\D+" if $flag==0; # pick out any non-numeric chars

@illegal_chars=$exp=~m/($regexp)/g;
   $illegal_chars_string=join(" ",@illegal_chars);
   if($exp=~m/$regexp/)
     {
      return (1,$illegal_chars_string) if ( wantarray );
      return 1;
     } ## found non-word char, so must return error
   if($exp!~m/$regexp/)
     {
      return (0,"null") if ( wantarray );
      return 0;
     } ## did not find non-word char

}

## 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;
}

## ------------------------------ End Subroutines --------------------------------------------

my $fractions_flag=0;   ### 0 - no fraction solver reference, 1 - fraction solver reference

foreach($my_a,$my_b,$my_c,$my_d)
{
 if($_=~m/[a-z]/)
 { 
 print "ERROR: Please enter numerical values only (no variables)";
 return;
 }
 if($_=~m/\//)
 {
 $fractions_flag=1;
 }
}

print " If you have the general 2x2 matrix: ";

print " {{{(matrix(2,2,a,b,c,d))}}} ";

print " the <a href=\"http://en.wikipedia.org/wiki/Determinant#2-by-2_matrices\">determinant</a> is: {{{D=a*d-c*b}}} ";

print " So this means that {{{abs(matrix(2,2,a,b,c,d))=a*d-c*b}}} ";

print " Note: the vertical bars denote a determinant. ";

print " ----------------------------------------------------------------- ";

print " So in this case the determinant of {{{(matrix(2,2,$my_a,$my_b,$my_c,$my_d))}}} is: 
";
my $product1=reduce(rat($my_a,$my_d,"*"));
$product1=~s/\/1$//; ## remove denominator of 1
my $product2=reduce(rat($my_c,$my_b,"*"));
$product2=~s/\/1$//; ## remove denominator of 1

my $sum=rat($product1,$product2,"-");
$sum=~s/\/1$//;  ## remove denominator of 1

my $ans=reduce($sum);
$ans=~s/\/1$//;  ## remove denominator of 1

print " {{{abs(matrix(2,2,$my_a,$my_b,$my_c,$my_d))=($my_a)($my_d)-($my_c)($my_b)=$product1-$product2=$sum";

print "=$ans" if $ans ne $sum;

print "}}} ";

if($fractions_flag==1)
{
 print " Note: if you are having trouble with the fractions, check out this <a href=\"http://www.algebra.com/algebra/homework/NumericFractions/fractions-solver.solver\">solver</a> ";
}

my $test=reduce(rat($my_a,$my_b,"*"));

print " ====================================================== ";

print " Answer: ";

print " So {{{abs(matrix(2,2,$my_a,$my_b,$my_c,$my_d))=$ans}}} which means that the determinant of the matrix {{{(matrix(2,2,$my_a,$my_b,$my_c,$my_d))}}} is $ans<\/font> ";

==section output

==section check