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

# methods -- list methods

## Description

## Synopsis

- Usage:
    `methods x`
- Inputs:
  - x, a function, a type, a keyword, or a package
- Outputs:
  - a vertical list of those methods associated with x

    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 => (poincare, BettiTally)                                }
         {13 => (hilbertPolynomial, ZZ, BettiTally)                   }
         {14 => (degree, BettiTally)                                  }
         {15 => (hilbertSeries, ZZ, BettiTally)                       }
         {16 => (pdim, BettiTally)                                    }
         {17 => (regularity, BettiTally)                              }
         {18 => (mathML, BettiTally)                                  }
         {19 => (truncate, BettiTally, InfiniteNumber, ZZ)            }
         {20 => (truncate, BettiTally, ZZ, InfiniteNumber)            }
         {21 => (truncate, BettiTally, InfiniteNumber, InfiniteNumber)}
         {22 => (codim, BettiTally)                                   }
         {23 => (truncate, BettiTally, ZZ, ZZ)                        }
         {24 => (dual, BettiTally)                                    }
         {25 => (^, Ring, BettiTally)                                 }

    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:
  - s, a symbol
  - X, a type
- 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:
  - X, a type
  - Y, a type
- Outputs:
  - a vertical list of those methods associated with

    i5 : methods( Matrix, Matrix )

    o5 = {0 => (diff', Matrix, Matrix)                               }
         {1 => (+, Matrix, Matrix)                                   }
         {2 => (-, Matrix, Matrix)                                   }
         {3 => (diff, Matrix, Matrix)                                }
         {4 => (contract', 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 => (%, Matrix, Matrix)                                  }
         {25 => (remainder, Matrix, Matrix)                          }
         {26 => (pushout, Matrix, Matrix)                            }
         {27 => (solve, Matrix, Matrix)                              }
         {28 => (pullback, Matrix, Matrix)                           }
         {29 => (tensor, Matrix, Matrix)                             }
         {30 => (intersect, Matrix, Matrix)                          }
         {31 => (intersect, Matrix, Matrix, Matrix, Matrix)          }
         {32 => (substitute, Matrix, Matrix)                         }
         {33 => (yonedaProduct, Matrix, Matrix)                      }
         {34 => (isShortExactSequence, Matrix, Matrix)               }
         {35 => (horseshoeResolution, Matrix, Matrix)                }
         {36 => (connectingExtMap, Module, Matrix, Matrix)           }
         {37 => (connectingExtMap, Matrix, Matrix, Module)           }
         {38 => (connectingTorMap, Module, Matrix, Matrix)           }
         {39 => (connectingTorMap, Matrix, Matrix, Module)           }
         {40 => (fourierMotzkin, Matrix, Matrix)                     }
         {41 => (checkDegrees, Matrix, Matrix)                       }
         {42 => (isIsomorphic, Matrix, Matrix)                       }
         {43 => (coneFromVData, Matrix, Matrix)                      }
         {44 => (coneFromHData, Matrix, Matrix)                      }
         {45 => (fan, Matrix, Matrix, List)                          }
         {46 => (fan, Matrix, Matrix, Sequence)                      }
         {47 => (polyhedralComplex, Matrix, Matrix, Matrix, List)    }
         {48 => (polyhedralComplex, Matrix, Matrix, List)            }
         {49 => (convexHull, Matrix, Matrix, Matrix)                 }
         {50 => (convexHull, Matrix, Matrix)                         }
         {51 => (polyhedronFromHData, Matrix, Matrix)                }
         {52 => (polyhedronFromHData, Matrix, Matrix, Matrix, Matrix)}
         {53 => (affineImage, Matrix, Polyhedron, Matrix)            }
         {54 => (affineImage, Matrix, Cone, Matrix)                  }
         {55 => (affinePreimage, Matrix, Polyhedron, Matrix)         }
         {56 => (affinePreimage, Matrix, Cone, Matrix)               }
         {57 => (regularSubdivision, Matrix, Matrix)                 }
         {58 => (jacobianDual, Matrix, Matrix, Matrix)               }
         {59 => (++, 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

- options(ZZ) -- get the optional arguments and default values of a function or method
- code(ZZ) -- display source code
- code(List) -- display source code
- locate(List) -- locate source code
- makeDocumentTag(List) -- the class of all document tags

## Ways to use methods:

- `methods(Command)`
- `methods(Manipulator)`
- `methods(Package)`
- `methods(ScriptedFunctor)`
- `methods(Sequence)`
- `methods(Symbol)`
- `methods(Thing)`
- `methods(Type)`

## For the programmer

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

The source of this document is in /build/macaulay2-88fgJW/macaulay2-1.25.11+ds/M2/Macaulay2/packages/Macaulay2Doc/ov_debugging.m2:752:0.