बिंदु पर पंक्तियों के बीच एक ग्रिड के अंदर एक विभक्त जोड़ने के लिए कोई चाल

Question

ग्रिड में पंक्तियों के बीच एक विभक्त जोड़ने के लिए, एक तरीका मुझे पता है कि इसे कैसे करना है Dividers विकल्प का उपयोग करके। लेकिन इसका अंत में उपयोग किया जाता है, और तब उसे उस पंक्ति संख्या को जानना चाहिए जिसमें विभाजक को इसके नीचे होना चाहिए। इसलिए, बड़े ग्रिड के लिए, जब तक मुझे सही पंक्ति संख्या नहीं मिल जाती, तब तक मैं खुद को परीक्षण और त्रुटि का उपयोग करता हूं। फिर जब मैं ग्रिड को बाद में बदलता हूं, तो मुझे अपने परिवर्तनों के बाद स्थानांतरित होने पर विभाजक को सही जगह पर रखने के लिए फिर से परीक्षण और त्रुटि करना पड़ता है।

इस उदाहरण में, वहाँ 3 पंक्तियों के साथ एक ग्रिड है और मैं विभक्त जोड़ने के लिए नीचे दूसरी पंक्ति कहना चाहते हैं, तो मैं ऐसा कर सकते हैं:

Grid[{ 
    {1}, 
    {2}, 
    {3} 
    }, Frame -> True, Dividers -> {All, 3 -> True}] 

एक और तरीका है, False और True डाल करने के लिए है, सही क्रम जहां मैं एक विभक्त चाहते हैं, यह

Grid[{ 
    {1}, 
    {2}, 
    {3} 
    }, Frame -> True, Dividers -> {All, {True, False, True, True}}] 

की तरह में यह अच्छा होगा अगर मैं की तरह कुछ कर सकता है इस (बिल्कुल इस नीचे यहाँ काम नहीं करता) (जैसे एक हेरफेर के लिए क्या कर सकते हैं)

Grid[{ 
    {1}, 
    {2}, 
    Delimiter, 
    {3} 
    }, Frame -> True] 

या

Grid[{ 
    {1}, 
    {Item[2,Dividers->True]}, 
    {3} 
    }, Frame -> True] 

या इस तरह के बात।

यह कोड रखरखाव को आसान बना देगा।

मैंने आइटम का उपयोग करने और इस तरह के लिए उपयोग करने पर देखा, लेकिन इसे समझने में सक्षम नहीं था।

कोई भी ऐसा करने के लिए एक चाल के बारे में जानता है?

संपादित करें:

btw, यह चाल यदि संभव हो तो, केवल डिवाइडर पर लागू नहीं होता। लेकिन यह कई अन्य ग्रिड विकल्पों को करने में सक्षम होना उपयोगी होगा, जो अब ग्रिड स्तर पर किया जाता है, साथ ही आइटम स्तर पर भी किया जा सकता है। उदाहरण के लिए, यदि मैं कुछ पंक्ति के बाद एक अतिरिक्त स्थान जोड़ना चाहता हूं, तो यह गति से इतना आसान कहना आसान होगा कि मैं यह चाहता था। इसके अलावा, अगर मैं आइटम आकार को बदलना चाहता था, तो स्पॉटिंग आदि के लिए इसे स्थान पर करना आसान था .. ताकि जब पूरी पंक्ति या वस्तु के लिए कोड को स्थानांतरित/प्रतिलिपि बनाते हैं, तो यह स्वयं निहित होता है और इसे सभी के साथ कॉपी करता है एक साथ विकल्प।

मुझे लगता है कि अब इसे सही तरीके से काम करने और सभी ग्रिड डिज़ाइन के साथ संगत होने के लिए गणित ग्रिड में एक नया विकल्प जोड़ने की आवश्यकता हो सकती है।

यह सब तब तक है जब तक एक जीयूआई निर्माता गणित के लिए नहीं बनाया जाता है।

मुझे लगता है कि जब मैं जीयूआई फिट करने और सही दिखने के लिए एक डेमो लिखता हूं तो मुझे लगता है कि मैं अपने समय का 60% से अधिक खर्च करता हूं। एक जीयूआई बिल्डर के साथ, मैं इस समय एल्गोरिदम पर काम कर सकता हूं। जब मैं जीयूआई बनाने के लिए मैटलैब गाइड का उपयोग करता हूं, तो मुझे एक समान जीयूआई बनाने के लिए मेरे समय का 5% से कम समय लगता है।

मेरी इच्छा है कि डब्ल्यूआरआई गणित के लिए एक जीयूआई निर्माता बनायेगा, मुझे लगता है कि अगर आप मुझसे पूछें तो यह गणित के लिए हत्यारा ऐप होगा। लेकिन कोई शरीर मुझे :)

संपादित करें (2)

नीचे श्री जादूगर अच्छा समाधान पर टिप्पणी के लिए कहा।
मैं मुख्य रूप से Manipulate के लिए लेआउट नियंत्रणों के लिए उपयोग किए गए ग्रिड के लिए यह सुविधा चाहता था। यहाँ एक सरल उदाहरण है:

Manipulate[x, 

Grid[{ 
    {Control[{{x, 0, "x"}, 0, 10, 1}]}, 
    {Control[{{y, 0, "y"}, 0, 10, 1}]} 
    }, Frame -> None, Dividers -> {None, {False, True, False}} 
    ] 
] 

(और मैं नियंत्रण स्थापित करने के लिए Grid उपयोग करने के लिए है)। मैं यहां फ़ंक्शन कॉल का उपयोग नहीं कर सकता। मैं नीचे दिए गए जादूगर के समाधान का उपयोग नहीं लिख सकते हैं, निम्नलिखित:

Manipulate[x, 

myGrid[{ 
    {Control[{{x, 0, "x"}, 0, 10, 1}]}, 
    spec["Divider"], 
    {Control[{{y, 0, "y"}, 0, 10, 1}]} 
    }, Frame -> None 
    ], 

Initialization :> 
    { 
    specfunc["Divider", lst_] := Dividers -> {None, # -> True & /@ lst}; 

    myGrid[dat_, opts : OptionsPattern[]] := 
    Module[{x = 1}, 
    Grid[#, opts, Sequence @@ #2] & @@ 
     Reap[If[MatchQ[#, _spec], Sow[x, #[[1]]]; ## &[], x++; #] & /@ 
     dat, _, specfunc] 
    ] 

    } 
] 

यह एक त्रुटि देता है, के बाद से मेथेमेटिका की कोशिश करता है पहले पढ़ने और आरंभीकरण खंड प्रक्रिया से पहले यह पार्स करने के लिए, हेरफेर के शरीर को पढ़ने के लिए।

लेकिन बाहर हेरफेर, यह बिल्कुल काम करेगा:

myGrid[{ 
    {Control[{{x, 0, "x"}, 0, 10, 1}]}, 
    spec["Divider"], 
    {Control[{{y, 0, "y"}, 0, 10, 1}]} 
    }, Frame -> None 
] 

specfunc["Divider", lst_] := Dividers -> {None, # -> True & /@ lst}; 
myGrid[dat_, opts : OptionsPattern[]] := 
Module[{x = 1}, 
    Grid[#, opts, Sequence @@ #2] & @@ 
    Reap[If[MatchQ[#, _spec], Sow[x, #[[1]]]; ## &[], x++; #] & /@ 
    dat, _, specfunc] 
    ] 

मैं अगर मैं इसके अंदर काम में हेरफेर करने के लिए प्राप्त कर सकते हैं देखने के लिए, इस पर अधिक समय बिताने की जरूरत है।

बीटीडब्ल्यू, मैनिपुलेट के अंदर काम करने के लिए इस तरह की चीजें प्राप्त करना वाकई मुश्किल है। केवल मुझे पता है कि लियोनीड से मैंने With[{},.... Grid....] पैटर्न के साथ मैक्रोज़ का उपयोग कर रहा है।

ऐसी कठिनाइयों के उदाहरण के लिए, मेरा यह प्रश्न देखें

How to define constants for use with With[] in one place and then apply them later?

संपादित करें (3) मैं कुछ गलत कर, लेकिन मैं कुछ त्रुटियाँ हो रही है अंदर हेरफेर हो मेरे में:

पहला उदाहरण:

Manipulate[x, 

Evaluate@grid[{ 
    {Control[{{x, 0, "x"}, 0, 10, 1}]} 
    } 
    ], 

Initialization :> 
    { 
    grid[tab_, opts___] := 
    Module[{divlocal, divglobal, div, pos}, 
     divglobal = (Dividers /. opts) /. Dividers -> {False, False}; 
     If[Depth[divglobal] == 1, divglobal = {divglobal, divglobal}]; 
     If[Length[divglobal] == 1, AppendTo[divglobal, False]]; 
     pos = Position[tab, Dividers -> _, 1]; 
     divlocal = 
     MapIndexed[# - #2[[1]] + 1 -> Dividers /. tab[[#]] &, 
     Flatten[pos]]; 
     divglobal[[2]] = {divglobal[[2]], divlocal}; 
     Grid[Delete[tab, pos], Dividers -> divglobal, opts]]; 


    } 
] 

erro देता है r:

ReplaceAll::rmix: Elements of {False,{}} are a mixture of lists and nonlists. >> 

ही अगर मैं Evaluate@ कोई भाग्य के स्थान पर

Evaluate@grid[{ 
    Dividers -> {Thick, Blue}, 
    {Control[{{x, 0, "x"}, 0, 10, 1}]} 
    } 
    ], 

की कोशिश की Dynamic@ के साथ ऊपर की जगह। छोटे फिक्स हो सकता है क्या जरूरत है? या मैं इसका उपयोग नहीं कर रहा हूँ?

Answer 1

यह समाधान आप उपयोग कर निर्दिष्ट उन के साथ तालिका में निर्दिष्ट पंक्तियों के बीच विभाजक के लिए विशिष्टताओं को गठबंधन करने के लिए अनुमति चाहिए Dividers विकल्प।

grid[tab_, opts___] := 
Module[{divlocal, divglobal, div, pos}, 

    (* extract option value of Dividers from opts to divglobal *) 
    (* default value is {False, False} *) 
    divglobal = (Dividers /. {opts}) /. Dividers -> {False, False}; 

    (* transform divglobal so that it is in the form {colspecs, rowspecs} *) 
    If[Head[divglobal] =!= List, divglobal = {divglobal, divglobal}]; 
    If[Length[divglobal] == 1, AppendTo[divglobal, False]]; 

    (* Extract positions of dividers between rows from tab *) 
    pos = Position[tab, Dividers -> _, 1]; 

    (* Build list of rules for divider specifications between rows *) 
    divlocal = MapIndexed[# - #2[[1]] + 1 -> Dividers /. tab[[#]] &, Flatten[pos]]; 

    (* Final settings for dividers are {colspecs, {rowspecs, divlocal}} *) 
    divglobal[[2]] = {divglobal[[2]], divlocal}; 
    Grid[Delete[tab, pos], Dividers -> divglobal, opts]] 

पंक्तियों आप इच्छित स्थान जहां spec या तो False, True है, या एक ग्राफिक्स निर्देश (रंग, मोटाई, आदि) पर Dividers->spec डालने की आवश्यकता के बीच एक विभक्त निर्दिष्ट करने के लिए। उदाहरण

tab = {{1, 2, 3}, Dividers -> {Thick, Blue}, {4, 5, 6}, {7, 8, 9}, 
    Dividers -> False, {10, 11, 12}}; 

grid[tab, Dividers -> All] 

संपादित

के लिए मैं श्री जादूगर के अनुरोध पर मेरी कोड के लिए कुछ टिप्पणियाँ जोड़ दिया है।

Answer 2

मैं प्रस्ताव करता हूं कि आप एक नए सिर का उपयोग करें जो निर्देश (spec नीचे) रख सकता है, और एक नया फ़ंक्शन जो इन निर्देशों (specfunc नीचे) को व्यक्तिगत रूप से आवश्यक रूप से संसाधित करता है। लाभ यह है कि यह विभिन्न अंतःस्थापित निर्देशों के लिए आसानी से सामान्यीकृत किया जाता है, और प्रत्येक को मनमाने तरीके से संसाधित किया जा सकता है।

specfunc["Divider", lst_] := Dividers -> {All, # -> True & /@ lst} 

myGrid[dat_, opts:OptionsPattern[]] := 
Module[{x = 1}, 
    Grid[#, opts, Sequence @@ #2] & @@ 
    Reap[ 
    If[MatchQ[#, _spec], Sow[x, #[[1]]]; ## &[], x++; #] & /@ dat, 
    _, 
    specfunc 
    ] 
] 

उपयोग:

dat = 
{ 
    {1, 2, 3}, 
    {4, 5, 6}, 
    spec["Divider"], 
    {7, 8, 9}, 
    spec["Divider"], 
    {"a", "b", "c"} 
}; 

myGrid[dat, Frame -> True] 

---

प्रत्येक अनुदेश "Divider" के रूप में ऐसी एक भी स्ट्रिंग हो सकती है और आपको कोई उन्हें इस तरह का उपयोग कर संघर्ष है, तो आप spec को समाप्त कर सकता है और MatchQ[#, _String] और Sow[x, #] का उपयोग करें।

---

, अपनी अपडेट किए गए सवाल को संबोधित करते के रूप में मैं एक टिप्पणी में नोट नीचे मुझे विश्वास है कि यह अपने अंतिम Manipulate वस्तु में सबसे बुनियादी तत्वों का उपयोग करने, और उपकरणों बारे में मदद करने के लिए आप सबसे अधिक आसानी से इस वस्तु उत्पन्न अधिक समझ में आता है। मेरा मानना ​​है कि Manipulate ब्लॉक के अंदर इन प्रकार के अनुकूलन को बनाने का प्रयास विफल होने के लिए बर्बाद हो गया है, और शायद अजीब और अपारदर्शी तरीकों से।

फिर भी, इस विशेष मामले इस काम करने के लिए, हालांकि मुझे शक है यह मजबूत है प्रकट होता है के लिए:

Manipulate[x, 
Evaluate[ 
    {specfunc["Divider", lst_] := Dividers -> {All, # -> True & /@ lst}; 
    myGrid[dat_, opts : OptionsPattern[]] := 
    Module[{x = 1}, 
    Grid[#, opts, Sequence @@ #2] & @@ 
     Reap[If[MatchQ[#, _spec], Sow[x, #[[1]]]; ## &[], x++; #] & /@ 
     dat, _, specfunc]]}; 
    myGrid[{{Control[{{x, 0, "x"}, 0, 10, 1}]}, 
    spec["Divider"], {Control[{{y, 0, "y"}, 0, 10, 1}]}}, 
    Frame -> True] 
    ] 
]