Wie füge ich ein Panel mit Definitionen zu Plots hinzu, begleitet von Punkt- und Punkt-Strich-Linien

  •  u = 2/(1 + Z1) Sech[T/Z1 + 1/(9 Z1) Log[1 + Z1]]^2;
    w = 2/(1 + Z2) Sech[T/Z2 + 1/(9 Z2) Log[1 + Z2]]^2;
    Z1 = 5;
    Z2 = 10;
    
    
    Plot[{u, w}, {T, -15, 15}, PlotRange -> {0, 0.45}, Frame -> True, 
     Axes -> {False, False}, 
     Epilog -> {Inset[
        Graphics[{DotDashed, Line[{{0, 0}, {0.19, 0}}]}], {10, 0.41}], 
       Inset["z=0.1", {13, 0.41}], 
       Inset[Graphics[{Dashed, Line[{{0, 0}, {0.19, 0}}]}], {10, 0.38}], 
       Inset["z=0.2", {13, 0.38}]}, PlotStyle -> {DotDashed, Dashed}]
     

    Wie füge ich ein Panel mit Definitionen zu Plots hinzu, begleitet von Punkt- und Punkt-Strich-Linien

    Wann möchte ich das Format ändern? das Plot in EPS, obwohl einige Teile des Plots, die mit Epilog und Inset (ich meine "_._. Z=0.1" und "_ _ _Z=0.2") programmiert wurden, ihre Formen ändern und den Plot unlesbar machen! Wie kann ich mein Programm überarbeiten? Ich denke, ich sollte Panel verwenden, aber ich weiß nicht wie!

    06 June 2012
    Szabolcs
2 answers
  •  -- for a given y = (y_1,...,y_n) and a bound m, find all vectors
    -- x = (x_1,...,x_n) such that |x| = m and x_i <= y_i
    boundSequences :: (Num a, Ord a, Enum a) => a -> [a] -> [[a]]
    boundSequences m x | m <= sum x = (fByM . sequence . ranges) x
                       | otherwise = [[]]
        where fByM = filter (\x -> sum x == m)
              ranges = map (\x -> [0..x])
     

    Abgesehen von einigen glücklichen Fällen verschwenden Sie hier viel Arbeit. sequence . ranges erstellt (y_1+1) * ... * (y_n+1) Listen, die Sie überprüfen müssen. Wenn Sie eine Funktion schreiben, um nur die erfolgreichen Listen zu erstellen, können Sie bei größeren Eingaben viel Leistung erzielen (für kurze Listen mit kleinen Elementen ist dies nicht zu viel, aber es wird auch für diese hilfreich sein).
    Sollte der Fall sum x < m nicht [] statt [[]] zurückgeben?

     -- return all the possible arc combinations  to an equivalence
    -- class for a given number of arcs
    connectionCombinations :: Int -> EquivClass -> [NodeSelection]
    connectionCombinations arcs = map groupOcc . prune arcs . sequence . orderRep
        where orderRep (EC o v) = replicate (length v) [0..o]
              prune a = nub . map (reverse . sort) . filter ((== a) . sum)
              groupOcc = filter ((/= 0) . fst) . occurences
     

    Verwenden Sie anstelle von reverse . sort sortBy (flip compare). Das macht für kurze Listen keinen großen Unterschied, aber es ist sauberer, IMO. prune arcs . sequence enthält ein weiteres Vorkommen des boundSequences -Problems, indem viele Listen erstellt und die meisten sofort herausgefiltert werden. nub ist nicht gut, es ist quadratisch (im schlechtesten Fall, O (total * verschieden) im Allgemeinen). Die Dinge, die Sie nubben, haben eine Instanz von Ord. Wenn die Reihenfolge keine Rolle spielt, ist map head . group . sort eine viel schnellere Nub als nub (noch besser Data.Set.toList . Data.Set.fromList). von gesehenen Elementen und für jedes neue, geben Sie das aus und fügen Sie es dem Satz von gesehen hinzu.

    Ich habe noch kein Profil, aber es kann sein, dass das Profil irreführend ist gibt den Funktionen Kosten zu, bei denen Ergebnisse erzwungen werden, statt Berechnungen durchzuführen, die etwas untersucht werden müssen, überprüfen Sie später erneut.

    Okay, die angegebenen Daten sind nicht lang genug Erstellen Sie ein aussagekräftiges Profil. Daher habe ich es in

     let cons = connections [EC 4 [1 .. 6], EC 6 [2 .. 9]] 5
     

    geändert. Das reicht, um eine Handvoll Proben zu sammeln. Leider war das Profil nicht sehr informativ:

         total time  =        7.90 secs   (395 ticks @ 20 ms)
        total alloc = 8,098,386,128 bytes  (excludes profiling overheads)
    COST CENTRE                    MODULE               %time %alloc
    connectionCombinations         Main                 100.0  100.0
     

    Also habe ich ein paar {-# SCC #-} Pragmas eingefügt. Der Biggo in diesem Programm ist das sequence . orderRep, was nicht überraschend ist. Ein Umschreiben entlang der oben genannten Zeilen,

     boundSequences :: (Num a, Ord a, Enum a) => a -> [a] -> [[a]]
    boundSequences m xs
        | sm < m    = []
        | sm == m   = [xs]
        | otherwise = go sm m xs
          where
            sm = sum xs
            go _ r []
                | r == 0 = [[]]
                | otherwise = []
            go _ r [y]
                | y < r     = []
                | otherwise = [[r]]
            go s r (y:ys) = do
                let mny | s < r+y   = r+y-s
                        | otherwise = 0
                    mxy = min y r
                c <- [mny .. mxy]
                map (c:) (go (s-y) (r-c) ys)
     

    und die Verwendung von connectionCombinations anstelle von prune arcs . sequence ( erfordert eine kleine Änderung in orderRep),

     connectionCombinations :: Int -> EquivClass -> [NodeSelection]
    connectionCombinations arcs = map groupOcc . nub . map (sortBy (flip compare)) . 
                                         boundSequences arcs . orderRep
        where orderRep (EC o v) = replicate (length v) o
              groupOcc = filter ((/= 0) . fst) . occurences
     

    brachte die Laufzeit (ghc -O2, kein Profiling) ) deutlich gesunken:

     [&&25 &
                                        
    01 December 2011
    Daniel Fischer
  • Wie in den Kommentaren erwähnt, sehen die Ergebnisse des EPS-Exports gut aus. Sie können jedoch eine alternative Version Ihrer Epilog mit einer einzelnen Inset verwenden, die mit skalierten Koordinaten wie folgt arbeitet:

     Epilog -> 
     Inset[
       Grid[{{Graphics[{DotDashed, Line[{{0, 0}, {1, 0}}]}, 
              AspectRatio -> .1, ImageSize -> 30], Style["z=0.1", 12]}, 
             {Graphics[{Dashed, Line[{{0, 0}, {1, 0}}]}, 
               AspectRatio -> .1, ImageSize -> 30], Style["z=0.2", 12]}}], 
       Offset[{-10, -10}, Scaled[{1, 1}]], {Right, Top}]
     

    (Weitere Informationen finden Sie Inset & gt; Anwendungen & gt; erstes Beispiel in den Dokumenten zum Inhalt und zur Platzierung von Insets.)

    Sie können Grid auch mit Panel:

    umschließen
     Epilog ->  Inset[Panel@Grid[...]]  
     

    Wenn Sie den Code Epilog->... durch diese Versionen ersetzen, erhalten Sie

    Wie füge ich ein Panel mit Definitionen zu Plots hinzu, begleitet von Punkt- und Punkt-Strich-Linien

    07 June 2012
    David Z