Macaulay2 » Documentation
Packages » Macaulay2Doc > The Macaulay2 language > methods
next | previous | forward | backward | up | index | toc

methods -- list methods

Description

Synopsis

i1 : methods BettiTally

o1 = {0 => (==, BettiTally, BettiTally)                           }
     {1 => (++, BettiTally, BettiTally)                           }
     {2 => (**, BettiTally, BettiTally)                           }
     {3 => (SPACE, BettiTally, Array)                             }
     {4 => (SPACE, BettiTally, ZZ)                                }
     {5 => (lift, BettiTally, ZZ)                                 }
     {6 => (*, QQ, BettiTally)                                    }
     {7 => (*, ZZ, BettiTally)                                    }
     {8 => (multigraded, BettiTally)                              }
     {9 => (net, BettiTally)                                      }
     {10 => (texMath, BettiTally)                                 }
     {11 => (betti, BettiTally)                                   }
     {12 => (pdim, BettiTally)                                    }
     {13 => (poincare, BettiTally)                                }
     {14 => (hilbertPolynomial, ZZ, BettiTally)                   }
     {15 => (degree, BettiTally)                                  }
     {16 => (hilbertSeries, ZZ, BettiTally)                       }
     {17 => (^, Ring, BettiTally)                                 }
     {18 => (regularity, BettiTally)                              }
     {19 => (mathML, BettiTally)                                  }
     {20 => (truncate, BettiTally, ZZ, InfiniteNumber)            }
     {21 => (truncate, BettiTally, ZZ, ZZ)                        }
     {22 => (codim, BettiTally)                                   }
     {23 => (truncate, BettiTally, InfiniteNumber, InfiniteNumber)}
     {24 => (dual, BettiTally)                                    }
     {25 => (truncate, BettiTally, InfiniteNumber, ZZ)            }

o1 : NumberedVerticalList
 
i2 : methods resolution

o2 = {0 => (resolution, Ideal) }
     {1 => (resolution, Module)}
     {2 => (resolution, Matrix)}

o2 : NumberedVerticalList
 
i3 : methods symbol @@

o3 = {0 => (@@, Function, Function)    }
     {1 => (@@, Expression, Expression)}
     {2 => (@@, Expression, Holder)    }
     {3 => (@@, Holder, Expression)    }
     {4 => (@@, Holder, Holder)        }
     {5 => (@@, Expression, Thing)     }
     {6 => (@@, Thing, Expression)     }
     {7 => ((@@, =), Type, Type)       }
     {8 => ((@@, =), Thing, Thing)     }
     {9 => (@@, Thing, Thing)          }

o3 : NumberedVerticalList

Synopsis

  • Usage:
    methods(s,X)
  • Inputs:
  • Outputs:
    • a vertical list of those methods associated with the operator s and the type X 
i4 : methods( symbol ++, Module)

o4 = {0 => (++, GradedModule, Module)}
     {1 => (++, Module, GradedModule)}
     {2 => (++, Module, Module)      }

o4 : NumberedVerticalList

Synopsis

  • Usage:
    methods(X,Y)
  • Inputs:
  • Outputs: 
i5 : methods( Matrix, Matrix )

o5 = {0 => (diff', Matrix, Matrix)                               }
     {1 => (+, Matrix, Matrix)                                   }
     {2 => (-, Matrix, Matrix)                                   }
     {3 => (contract, Matrix, Matrix)                            }
     {4 => (diff, Matrix, Matrix)                                }
     {5 => (contract', Matrix, Matrix)                           }
     {6 => (markedGB, Matrix, Matrix)                            }
     {7 => (Hom, Matrix, Matrix)                                 }
     {8 => (==, Matrix, Matrix)                                  }
     {9 => (*, Matrix, Matrix)                                   }
     {10 => (|, Matrix, Matrix)                                  }
     {11 => (||, Matrix, Matrix)                                 }
     {12 => (subquotient, Matrix, Matrix)                        }
     {13 => (subquotient, Module, Matrix, Matrix)                }
     {14 => (**, Matrix, Matrix)                                 }
     {15 => (homology, Matrix, Matrix)                           }
     {16 => (modulo, Matrix, Matrix)                             }
     {17 => (quotientRemainder', Matrix, Matrix)                 }
     {18 => (quotientRemainder, Matrix, Matrix)                  }
     {19 => (//, Matrix, Matrix)                                 }
     {20 => (\\, Matrix, Matrix)                                 }
     {21 => (quotient', Matrix, Matrix)                          }
     {22 => (quotient, Matrix, Matrix)                           }
     {23 => (remainder', Matrix, Matrix)                         }
     {24 => (remainder, Matrix, Matrix)                          }
     {25 => (%, Matrix, Matrix)                                  }
     {26 => (pushout, Matrix, Matrix)                            }
     {27 => (solve, Matrix, Matrix)                              }
     {28 => (tensor, Matrix, Matrix)                             }
     {29 => (pullback, Matrix, Matrix)                           }
     {30 => (intersection, Matrix, Matrix)                       }
     {31 => (intersection, Matrix, Matrix, Matrix, Matrix)       }
     {32 => (substitute, Matrix, Matrix)                         }
     {33 => (checkDegrees, Matrix, Matrix)                       }
     {34 => (isIsomorphic, Matrix, Matrix)                       }
     {35 => (coneFromVData, Matrix, Matrix)                      }
     {36 => (coneFromHData, Matrix, Matrix)                      }
     {37 => (fan, Matrix, Matrix, List)                          }
     {38 => (fan, Matrix, Matrix, Sequence)                      }
     {39 => (polyhedralComplex, Matrix, Matrix, Matrix, List)    }
     {40 => (polyhedralComplex, Matrix, Matrix, List)            }
     {41 => (convexHull, Matrix, Matrix, Matrix)                 }
     {42 => (convexHull, Matrix, Matrix)                         }
     {43 => (polyhedronFromHData, Matrix, Matrix)                }
     {44 => (polyhedronFromHData, Matrix, Matrix, Matrix, Matrix)}
     {45 => (affineImage, Matrix, Polyhedron, Matrix)            }
     {46 => (affineImage, Matrix, Cone, Matrix)                  }
     {47 => (affinePreimage, Matrix, Polyhedron, Matrix)         }
     {48 => (affinePreimage, Matrix, Cone, Matrix)               }
     {49 => (regularSubdivision, Matrix, Matrix)                 }
     {50 => (jacobianDual, Matrix, Matrix, Matrix)               }
     {51 => (isLiftable, Matrix, Matrix)                         }
     {52 => (++, Matrix, Matrix)                                 }

o5 : NumberedVerticalList
This function operates by examining those types that are values of global symbols for keys that appear to be storing references to methods. Types that don't appear as values of global variables will not be examined, so perhaps not all methods will be found.

See also

Ways to use methods:

For the programmer

The object methods is a method function with a single argument.