Code transcripts

Session 1

session_1.m2

1+1

k = ZZ/11
k = QQ
1/2
k = RR

k = QQ
R = k[x,y,z,w]

x + y^2 - w*x

I = ideal(x^2, y^2, z^2)
J = ideal(x*y*z)

I + J
intersect(I,J)

R/I  -- Ring of polynomials with x,y,z degree <= 1, w degree anything

use (R/I) -- Ties variables to the ring R/I instead of R
x^3

k
k = ideal(x+y+z)
k
k = symbol k -- To "deassign" a variable

-- indexed variables
x = symbol x
R = QQ[x_0,x_1,x_2,x_3]
R = QQ[x_0..x_3]
vars R

x_0

R = symbol R
R = ring x_0

-- order matters
restart
R = QQ[x,y,z]
I = ideal(x+y)
S = QQ[x,y]
J = ideal(x+y)

J == I -- is I and J equal?
sub(J, R) == I

use R
K = ideal(x+y+z)
sub(K, S) -- sub is a bit dangerous

use R
phi = map(R, S, {x,y})
phi J -- equivalent to sub(J,R) in this case

describe S
use S
psi = map(S,R,{x,y,0})
psi K -- equivalent to sub(K,S) in this case

restart
R = QQ[x,y,a, MonomialOrder => Lex, Degrees => {{-1,2}, {2,3}, {4,5}}]
x > y
a > y

x > a^102832

3:1
degree(x^2*y^3)
degree(x)

describe R


-- finding things
viewHelp
viewHelp inverse
?inverse
apropos "inverse"
viewHelp ideal

--
-- lists
l = { "abc", I, R }
l#0
l#1
l#2

l | { hello, "hello" }

s = ("abc", I, R)
a..t
(0,0)..(6,4) -- sequence
toList((0,0)..(6,4)) --list

(0,0)..<(6,4) -- sequence
0..<7
0..(7-1)

s = a..c

x = symbol x
s = x_(0,0)..x_(3,3)

reverse(0..10)
reverse(a..z)

R = QQ[s]
describe R

Session 2

session_2.m2

-- Best practices
restart

f = i -> i+1

f 7
f(5)

g = (a,b,c) -> (a+2, b+3, c+7)
g(1,7,-3)

R = QQ[x,y]
J = 17

complicated = I -> (
  J := radical I; -- J is local to the function scope, := 
  if J == ideal(x,y) then return ideal(0_R);
  return (J + ideal(x,y))
)

complicated(ideal(x^2+7))
complicated(ideal(x,y))

I = ideal(x,y)
if I == ideal(x,y) then (
  print("Hello!");
  I
)

for i from 0 to 7 do ( print(i) )
for i from 0 to 7 list ( i^2 )

-- Don't
l = {}
for i from 0 to 7 do (
  l = l | {i^2}
)
l
---

-- kind of OK, but
for word in {"my", "name", "is"} do print word

viewHelp apply
apply(toList(0..7), i -> i^2)
toList(0..7) / (i -> i^2) -- same as above

R = QQ[x,y,z,w]
I = ideal(x^2+y, y^2-x*z, w*x)
prim_dec = primaryDecomposition I
prim_dec / dim

primaryDecomposition I / radical // unique -- equivalent to
unique(apply(primaryDecomposition I, radical))

unique({1,2,3,2,2})
S = QQ[ subsets(4,2) / (i -> p_i) ]
describe S

gens gb I

viewHelp forceGB

viewHelp

R = QQ[x,y, MonomialOrder => ]

matrix{{1,2}}

load "my_functions.m2"
f(1)
g(4)

BestPackage

BestPackage.m2

newPackage(
  "BestPackage",
  Headline => "an amazing package",
  Version => "1.0"
)

export {"bestMethod"}

bestMethod = method()
bestMethod ZZ := String => i -> if i == 0 then "hello" else "bye"

TEST ///
assert(bestMethod(0) == "hello")
///

beginDocumentation()

doc ///
Key
  BestPackage
Headline
  a great package
///


doc ///
Key
  bestMethod
  (bestMethod, ZZ)
Headline
  a great method, for integers
Usage
  greeting = bestMethod(i)
Inputs
  i:ZZ
    either 1 or something else
Outputs
  greeting:String
    a nice greeting
Description
  Text
    This method outputs a nice greeting based on input. The integer 0 gives a hello
  Example
    bestMethod(0)
  Text
    Any other input says goodbye
  Example
    bestMethod(123)
///

end


restart
uninstallPackage "BestPackage"
installPackage "BestPackage"
viewHelp BestPackage

needsPackage "BestPackage" -- load package
check BestPackage -- run all tests

bestMethod(1)
bestMethod(0)

viewHelp BestPackage

-- for inspiration for package documentation
needsPackage "SimpleDoc"
viewHelp SimpleDoc




needsPackage "Graphs"
viewHelp Graphs

R = QQ[x,y,z]
I = ideal(x^2)
amult I

needsPackage "SimpleDoc"
viewHelp SimpleDoc


-- HashTable
ht = hashTable { h => "Hello", b => "Bye" }

h
b
ht.h
ht.b
ht.akjhsdas

ht

ancestors class I
peek I
I.ring
peek I.cache

f = i -> i+1
f(7)
f(7/2)
f(I)

g = method()
g(7)

g ZZ := ZZ => i -> i^2    -- <method name> <input type> := <output type> => i -> i^2
g QQ := QQ => i -> i^2    -- <method name> <input type> := <output type> => i -> i^2
g(7)
g(1/2)
g(I)

g (QQ, QQ) := QQ => (i,j) -> i^2 + j^2   -- <method name> <input type> := <output type> => i -> i^2
g(1/2, 3/4)


h = method(Options => { Shift => 0 })
h ZZ := ZZ => opts -> i -> i + 1 + opts.Shift

h(7)
h(7, Shift => 27)

viewHelp newRing
options newRing
options h

Session 4

session_4.m2

restart

ht = hashTable { 7 => "hello", b => "goodbye", QQ => "rational"}

ht.b
ht#b
ht#7
ht#QQ

b = 123
ht#b
ht.b


class QQ
class {1,2,3}

ancestors class {1,2,3}
ancestors class (1,2,3)

g = method()
g Thing := i -> i + 1

ancestors Ideal

g(7)
g(ideal 1)

-------------

-- trigger an error
error "error is here"

R = QQ[x,y]
ideal(x)
oo + ideal(y)
ooo + ideal(y^2)
oooo + ideal(y^3)

viewHelp "gbTrace"
gbTrace = 3

R = QQ[x,y,z, MonomialOrder => Lex]
I = ideal(x^9 + y^3 + z^2 - 1, x^7 + y^5 + z^3 - 1)
gens gb I -- Ctrl + C to interrups

R = QQ[x,y,z, MonomialOrder => Lex]
ideal(x^3 + y^3 + z^2 - 1, x^7 + y^5 + z^3 - 1)
gbTrace = 0
elapsedTime gens gb I;


oo
o84
o87

gens R
R_0
R_1

0_R
1_R

map(R^1,R^1,1)
methods map
viewHelp map

x = symbol x;
R = QQ[x_1,x_2]
x_1

f = n -> (
  x := symbol x;
  R := QQ[x_1..x_n];
  ideal gens R
)

x_1
f 3
x_1

restart
R = QQ[x,y]
x

f = () -> QQ[x,y]; -- bad, this "uses" the newly created ring,
                    -- messing up user variables

f = () -> QQ( monoid [x,y]); -- fix, doesn't use the new ring

f()

x
use R
x