From 0dbb68555b731d4235ac28421caf6f66ad567d81 Mon Sep 17 00:00:00 2001 From: LiRuoChen <571244399@qq.com> Date: Thu, 10 Apr 2025 15:32:00 +0800 Subject: [PATCH] init push 0.2.4 --- CHANGELOG.md | 119 + ConfigUIElement/Lrss3.ConfigUIElement.asmdef | 17 + .../Scripts/Element/ConfigButton.cs | 62 + .../Element/ConfigDigitalInputField.cs | 153 + .../Scripts/Element/ConfigDropdown.cs | 78 + .../Scripts/Element/ConfigSelectableItem.cs | 712 + .../Scripts/Element/ConfigTextInputField.cs | 100 + .../Scripts/Element/ConfigToggleGroup.cs | 86 + .../Element/ConfigTypeOverrideAttribute.cs | 38 + .../Scripts/Element/ConfigVec2InputField.cs | 129 + .../Scripts/Element/ConfigVec3InputField.cs | 158 + Documentation/Sesotho Line.md | 169 + .../images/Screenshot 2024-04-28 092352.jpg | Bin 0 -> 215509 bytes .../SesothoPeManagerEditor.cs | 154 + Editor/Lrss3.Deconstruction.Editor.asmdef | 19 + Editor/UI/CircleSliderEditor.cs | 73 + LICENSE | 21 + LICENSE.meta | 7 + README.en.md | 36 + README.en.md.meta | 7 + README.md | 314 + README.md.meta | 7 + Resources/Material/Graph/Lit/SceneGround.mat | 117 + .../Graph/Lit/SceneGroundGraphs.shadergraph | 1212 + .../Material/Graph/UI/UISelectionBoxDraw.mat | 157 + .../Graph/UI/UISelectionBoxGraphs.shadergraph | 8176 +++ Resources/Meshs/EditorTool/6m高立方体.fbx | Bin 0 -> 15180 bytes .../Meshs/EditorTool/单位立方体的3d选框.fbx | Bin 0 -> 18124 bytes .../ConfigUIItem/ConfigDigiteInput.prefab | 1416 + .../Prefab/ConfigUIItem/ConfigDropDown.prefab | 1844 + .../ConfigUIItem/ConfigInputVec2.prefab | 1688 + .../ConfigUIItem/ConfigInputVec3.prefab | 2210 + .../ConfigUIItem/ConfigToggleGroup.prefab | 1413 + Resources/Sprite/EnptyAlphaMask.png | Bin 0 -> 102 bytes Resources/Sprite/NoSingnal.png | Bin 0 -> 27242 bytes Resources/Sprite/arrow/downArrow.png | Bin 0 -> 281 bytes Resources/Sprite/arrow/leftArrow.png | Bin 0 -> 314 bytes Resources/Sprite/arrow/rightArrow.png | Bin 0 -> 302 bytes Resources/Sprite/arrow/upArrow.png | Bin 0 -> 251 bytes Runtime/AGV/Scripts/AGVSettingsManager.cs | 21 + Runtime/Deconstruction.xml | 3410 + Runtime/EditorTool/ShowMyNameInScene.cs | 132 + Runtime/Helper/XericHelper.cs | 31 + .../.idea/encodings.xml | 4 + .../.idea/indexLayout.xml | 8 + .../.idea/projectSettingsUpdater.xml | 6 + .../.idea.HorizonLineOrbit.dir/.idea/vcs.xml | 6 + .../.idea/workspace.xml | 60 + .../DrawTerminalLine2T3_OpSlot.cs | 365 + Runtime/HorizonLineOrbit/ILinkconfident.cs | 24 + Runtime/HorizonLineOrbit/ILinkconfidentPe.cs | 13 + .../SesothoArrangementWiresTool.cs | 558 + Runtime/HorizonLineOrbit/SesothoPeManager.cs | 187 + Runtime/HorizonLineOrbit/TerminalLine2T3.cs | 224 + Runtime/HorizonLineOrbit/TerminalPoint.cs | 72 + Runtime/Lrss3.Deconstruction.asmdef | 16 + Runtime/MathNet.Numerics.xml | 53733 ++++++++++++++++ Runtime/Player/CameraController.cs | 293 + Runtime/Resources/Icon/deepseek_icon_long.png | Bin 0 -> 37483 bytes Runtime/Resources/Icon/deepseek_icon_s.png | Bin 0 -> 12398 bytes Runtime/StructType/GowSoftRef.cs | 109 + Runtime/UI/AutoCanvasScale.cs | 64 + Runtime/UI/CircleSlider.cs | 429 + Runtime/UI/MacroUI.cs | 494 + Runtime/UI/WeaklyUIBehaviour.cs | 95 + Runtime/XericLibrary.xml | 11970 ++++ Samples~/Example/.sample.json | 5 + Samples~/Example/SampleExample.cs | 28 + Tests/Editor/EditorExampleTest.cs | 29 + .../Lrss3.SesothoLine.Editor.Tests.asmdef | 14 + Tests/Runtime/Lrss3.SesothoLine.Tests.asmdef | 11 + Tests/Runtime/RuntimeExampleTest.cs | 28 + Third Party Notices.md | 16 + package.json | 15 + 74 files changed, 93162 insertions(+) create mode 100644 CHANGELOG.md create mode 100644 ConfigUIElement/Lrss3.ConfigUIElement.asmdef create mode 100644 ConfigUIElement/Scripts/Element/ConfigButton.cs create mode 100644 ConfigUIElement/Scripts/Element/ConfigDigitalInputField.cs create mode 100644 ConfigUIElement/Scripts/Element/ConfigDropdown.cs create mode 100644 ConfigUIElement/Scripts/Element/ConfigSelectableItem.cs create mode 100644 ConfigUIElement/Scripts/Element/ConfigTextInputField.cs create mode 100644 ConfigUIElement/Scripts/Element/ConfigToggleGroup.cs create mode 100644 ConfigUIElement/Scripts/Element/ConfigTypeOverrideAttribute.cs create mode 100644 ConfigUIElement/Scripts/Element/ConfigVec2InputField.cs create mode 100644 ConfigUIElement/Scripts/Element/ConfigVec3InputField.cs create mode 100644 Documentation/Sesotho Line.md create mode 100644 Documentation/images/Screenshot 2024-04-28 092352.jpg create mode 100644 Editor/HorizonLineOrbit/SesothoPeManagerEditor.cs create mode 100644 Editor/Lrss3.Deconstruction.Editor.asmdef create mode 100644 Editor/UI/CircleSliderEditor.cs create mode 100644 LICENSE create mode 100644 LICENSE.meta create mode 100644 README.en.md create mode 100644 README.en.md.meta create mode 100644 README.md create mode 100644 README.md.meta create mode 100644 Resources/Material/Graph/Lit/SceneGround.mat create mode 100644 Resources/Material/Graph/Lit/SceneGroundGraphs.shadergraph create mode 100644 Resources/Material/Graph/UI/UISelectionBoxDraw.mat create mode 100644 Resources/Material/Graph/UI/UISelectionBoxGraphs.shadergraph create mode 100644 Resources/Meshs/EditorTool/6m高立方体.fbx create mode 100644 Resources/Meshs/EditorTool/单位立方体的3d选框.fbx create mode 100644 Resources/Prefab/ConfigUIItem/ConfigDigiteInput.prefab create mode 100644 Resources/Prefab/ConfigUIItem/ConfigDropDown.prefab create mode 100644 Resources/Prefab/ConfigUIItem/ConfigInputVec2.prefab create mode 100644 Resources/Prefab/ConfigUIItem/ConfigInputVec3.prefab create mode 100644 Resources/Prefab/ConfigUIItem/ConfigToggleGroup.prefab create mode 100644 Resources/Sprite/EnptyAlphaMask.png create mode 100644 Resources/Sprite/NoSingnal.png create mode 100644 Resources/Sprite/arrow/downArrow.png create mode 100644 Resources/Sprite/arrow/leftArrow.png create mode 100644 Resources/Sprite/arrow/rightArrow.png create mode 100644 Resources/Sprite/arrow/upArrow.png create mode 100644 Runtime/AGV/Scripts/AGVSettingsManager.cs create mode 100644 Runtime/Deconstruction.xml create mode 100644 Runtime/EditorTool/ShowMyNameInScene.cs create mode 100644 Runtime/Helper/XericHelper.cs create mode 100644 Runtime/HorizonLineOrbit/.idea/.idea.HorizonLineOrbit.dir/.idea/encodings.xml create mode 100644 Runtime/HorizonLineOrbit/.idea/.idea.HorizonLineOrbit.dir/.idea/indexLayout.xml create mode 100644 Runtime/HorizonLineOrbit/.idea/.idea.HorizonLineOrbit.dir/.idea/projectSettingsUpdater.xml create mode 100644 Runtime/HorizonLineOrbit/.idea/.idea.HorizonLineOrbit.dir/.idea/vcs.xml create mode 100644 Runtime/HorizonLineOrbit/.idea/.idea.HorizonLineOrbit.dir/.idea/workspace.xml create mode 100644 Runtime/HorizonLineOrbit/DrawTerminalLine2T3_OpSlot.cs create mode 100644 Runtime/HorizonLineOrbit/ILinkconfident.cs create mode 100644 Runtime/HorizonLineOrbit/ILinkconfidentPe.cs create mode 100644 Runtime/HorizonLineOrbit/SesothoArrangementWiresTool.cs create mode 100644 Runtime/HorizonLineOrbit/SesothoPeManager.cs create mode 100644 Runtime/HorizonLineOrbit/TerminalLine2T3.cs create mode 100644 Runtime/HorizonLineOrbit/TerminalPoint.cs create mode 100644 Runtime/Lrss3.Deconstruction.asmdef create mode 100644 Runtime/MathNet.Numerics.xml create mode 100644 Runtime/Player/CameraController.cs create mode 100644 Runtime/Resources/Icon/deepseek_icon_long.png create mode 100644 Runtime/Resources/Icon/deepseek_icon_s.png create mode 100644 Runtime/StructType/GowSoftRef.cs create mode 100644 Runtime/UI/AutoCanvasScale.cs create mode 100644 Runtime/UI/CircleSlider.cs create mode 100644 Runtime/UI/MacroUI.cs create mode 100644 Runtime/UI/WeaklyUIBehaviour.cs create mode 100644 Runtime/XericLibrary.xml create mode 100644 Samples~/Example/.sample.json create mode 100644 Samples~/Example/SampleExample.cs create mode 100644 Tests/Editor/EditorExampleTest.cs create mode 100644 Tests/Editor/Lrss3.SesothoLine.Editor.Tests.asmdef create mode 100644 Tests/Runtime/Lrss3.SesothoLine.Tests.asmdef create mode 100644 Tests/Runtime/RuntimeExampleTest.cs create mode 100644 Third Party Notices.md create mode 100644 package.json diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000..7c228cd --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,119 @@ +# Changelog + +## [0.3.1] - 2025-01-10 + +一个大功能更新：数据库宏 +添加了一个关于数据库读写的部分，将数据库的sql语言用更易管理的方式封装。 +数据库宏需要对应的数据库dll支持，为了便于分发，暂时没有纳入自动封装的范围 +数据库宏分为两个部分： +一个以order为基础，封装了基本操作指令的操作库。 +一个以关键字函数式为基础，允许使用链式语法构建指令的指令集，依靠编译器实现语法。 + +自上次以来，添加其他的一些小功能： +可以对一个字符串使用.InXml_xxx来快速使用xml格式包裹文本。 +调整了mono单例的一些单例模式，添加了惰性单例，编辑时单例，匿名单例，旁路优先单例，终端单例，现在一共可以用9种单例。 +添加了一个关于user32.dll的控制宏。 + +## [0.2.6] - 2024-10-10 + +添加了程序宏: +单例类中添加了对自源与他源的区分,替代了之前的抛出异常,而是可以通过不同的属性分别获取自己的单例和源自自己的单例. +添加了ui变换宏; +添加了摄像机宏：可以在编辑器下获取屏幕尺寸（用于解决当前高版本下获取低版本untiy的screen参数时总是不对的问题）； + +## [0.2.5] - 2024-8-12 + +添加了列表宏：列表二分法迭代器，合并迭代器之前，合并迭代器之后，获取子迭代器片段，。 +添加了对象宏：广度优先节点迭代器，深度优先节点迭代器，获取家族序列，从家族序列查找对象。 +添加了树型结构：目录树。 +添加了超驰宏。 +添加了硬件信息查询，不过相关命令在unity里无法执行，需要系统权限。 +添加了一维到三维布尔数据结构。 +添加了按键宏，可以识别点击，长按，双击，连击，长按释放等操作，支持动作触发，时间触发，坐标触发。 +添加了一个测试用的角色控制器，默认使用旧输入系统，不过有提供便捷的重写结构。 +添加了编辑距离检查算法。 +添加了3d贝塞尔曲线（样条曲线），适用于3d世界场景。 +添加了2d界面的贝塞尔曲线，适用于ui界面，可以跟随界面定位缩放。 +添加了注册器。 + +之前更改的weaklyMono类在判断空方面有点繁琐，所以添加了 IsNull 和 sNotNull 来判断 weaklyMono 是否为空。 + +修复了颜色梯度图表的一个编辑时错误，现在不会在每次展开inspector时添加默认值在0点了。 +修复了一些快捷枚举位操作宏会出现计算错误的情况。 +修复了数学库中的clamp计算错误。 + +## [0.2.4] - 2024-06-19 + +添加了更多的关于快速文件保存，数据算法，html解析，http连接的扩展实现。 +对于线路绘制库没有进行过多更改，但修复了一些可能存在的问题。 +添加了基于机器码的简易认证。 + +## [0.2.3-alpha] - 2024-06-14 + +主要添加了一些关于弱元素的扩展 +这是一个测试版本，基于上一版本进行更新，并调整了部分实验性API。 + +* 注意 +现在想要判断一个线路绘制库的元素是否为空，必须明确指出其空类型，或者使用 is null 以及 is not null 来更规范地检查是否为空。 +另外我在测试环境中的代码在此次更新中没有发生任何报错或警告，所以我认为这依然是一个小更新。 +但在未来可能会将此类语法扩展到其他类成员中，请悉知。 + +* 新增 +增加一些许可证行为。 +增加一些基础网络相关库。 + +* API调整 +重新设计了线路绘制库中序列化联盟的结构扩展，链式语法更紧凑了。 +同时反序列化的内容可以直接用于复制，同化等操作，并且逐组件同化的操作也可以使用快速链式调用了。 +已经被移除的旧方法大部分是非公开的，所以这算小更新，如果你通过软引用调用了旧api，请参考组件中新的反序列化进行调整。 +相连结构的检查接口包含新增与修改。 + +* 修复 +修复了线路绘制库中对线路的反序列化功能。 +修复了序列化联盟中存在的一些索引问题。 + +* 已知问题 +在电脑休眠后，untiy有几率会提示插件中的部分类missing the class attribute ‘ExtensionOfNativeClass’。 + + +## [0.2.2-alpha] - 2024-05-22 + +主要对线路绘制库的更新，以及对少量数学库的更新。 +这是一个测试版本，基于上一版本进行更新，并调整了部分实验性API。 + +* 新增 +添加了uid的全局存在查找功能。 +添加了序列化保存的功能。 +添加了线路吸附，并实装在工具中。 +添加了工具类的后台运行生命周期。 + +* API调整 +将原先添加巨大成员对象的方法中外置的空间转换方法隐去，而在IPossessorTrajectory2中添加了对默认可扩展的两种世界空间的默认转换方法。由于只有具备可执行脚本能力的类才可以继承此接口，因此在此处添加世界空间的转换方法个人认为是较为恰当的。 +移除了材质库，材质库现在独立为了新的插件。 + +* 修复 +修复了圆弧计算时，步长会随着半径提高而边长的问题，经过测试是正比关系，依此完成的矫正。 + + +## [0.2.1-alpha] - 2024-05-07 + +这是一个测试版本，但其中的api基本确定，可以进行基本的使用。 + + +## [0.2.0] - 2024-04-18 + +开始加入线路库*解构*功能 + +添加点，线的计算与绘制功能，以及全局标识。 + +## [0.1.0] - 2024-01-30 + +插件源自一个简单的数学整合库。 +现整合基本内容，并在此基础上编写线路库，期望通过dll封装形成大型但简洁的库。 + +简洁是可选的，移除不需要的dll功能即可。 + + +### This is the first release of *\*. + +*Short description of this release* diff --git a/ConfigUIElement/Lrss3.ConfigUIElement.asmdef b/ConfigUIElement/Lrss3.ConfigUIElement.asmdef new file mode 100644 index 0000000..c0769c2 --- /dev/null +++ b/ConfigUIElement/Lrss3.ConfigUIElement.asmdef @@ -0,0 +1,17 @@ +{ + "name": "Lrss3.ConfigUIElement", + "rootNamespace": "", + "references": [ + "GUID:6055be8ebefd69e48b49212b09b47b2f", + "GUID:b1727b829ae4f0641acc8ad28ed624c2" + ], + "includePlatforms": [], + "excludePlatforms": [], + "allowUnsafeCode": false, + "overrideReferences": false, + "precompiledReferences": [], + "autoReferenced": true, + "defineConstraints": [], + "versionDefines": [], + "noEngineReferences": false +} \ No newline at end of file diff --git a/ConfigUIElement/Scripts/Element/ConfigButton.cs b/ConfigUIElement/Scripts/Element/ConfigButton.cs new file mode 100644 index 0000000..2632488 --- /dev/null +++ b/ConfigUIElement/Scripts/Element/ConfigButton.cs @@ -0,0 +1,62 @@ +using System.Collections; +using System.Collections.Generic; +using UnityEngine; +using UnityEngine.EventSystems; +using UnityEngine.UI; + +namespace LRC +{ + public class ConfigButton : ConfigSelectableItem + { + #region ֶ + + public Button targetButton; + + public override bool AllowInput + { + get => base.AllowInput; + set + { + if (targetButton != null) + targetButton.interactable = !value; + base.AllowInput = value; + } + } + + #endregion + + #region ʵ + + protected override void SetValue(object newValue) + { + throw new System.NotImplementedException(); + } + + public override void RefreshValueWithoutEvent(object newValue, bool forceSet = false) + { + base.RefreshValueWithoutEvent(newValue, forceSet); + } + + private bool _doOnce = false; + protected override void Initialization_ChildConstruction(UIBehaviour component) + { + base.Initialization_ChildConstruction(component); + + var name = component.transform.name; + if (name is not "button") return; + if (_doOnce) + { + Debug.LogError("ظģ飺" + name); + return; + } + if (component is Button button) + { + _doOnce = true; + if (targetButton != null) + targetButton = button; + } + } + + #endregion + } +} \ No newline at end of file diff --git a/ConfigUIElement/Scripts/Element/ConfigDigitalInputField.cs b/ConfigUIElement/Scripts/Element/ConfigDigitalInputField.cs new file mode 100644 index 0000000..890062c --- /dev/null +++ b/ConfigUIElement/Scripts/Element/ConfigDigitalInputField.cs @@ -0,0 +1,153 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using TMPro; +using UnityEngine; +using UnityEngine.EventSystems; +using UnityEngine.UI; + +namespace LRC +{ + /// + /// һֵ򣬽ʹøֵΪĬ + /// + public class ConfigDigitalInputField : ConfigSelectableItem + { + #region ֶ + +#if UNITY_EDITOR + public float editorInput; +#endif + + public TMP_InputField targetInput; + + public Button digitalAddButton; + public Button digitalSubButton; + + public double maxValue = 114514; + public double minValue = -114515; + public int digits = 6; + + /// + /// + /// + public double delta = 1; + + public override bool AllowInput + { + get => base.AllowInput; + set + { + if (targetInput != null) + targetInput.readOnly = !value; + if (digitalAddButton != null) + digitalAddButton.interactable = value; + if (digitalSubButton != null) + digitalSubButton.interactable = value; + base.AllowInput = value; + } + } + + #endregion + + #region + + protected override void OnValidate() + { + base.OnValidate(); +#if UNITY_EDITOR + if (targetInput != null) + targetInput.text = editorInput.ToString(); +#endif + } + + protected override void Awake() + { + base.Awake(); + if (ReferenceEquals(targetInput, null)) + { + Debug.LogError($"{name}ĿĿĻԪز"); + return; + } + targetInput.onSelect.AddListener(a => + { + WhenStartEdit(); + }); + targetInput.onValueChanged.AddListener(o => + { + double value = 0; + if (double.TryParse(o, out value)) + { + SetValue(value); + } + }); + targetInput.onEndEdit.AddListener(delegate + { + WhenEndEdit(); + }); + if (!ReferenceEquals(digitalAddButton, null)) + digitalAddButton.onClick.AddListener(delegate + { + SetValue(CastDigitalNumber(Value) + delta); + RefreshFormatValue(Value); + }); + if (!ReferenceEquals(digitalSubButton, null)) + digitalSubButton.onClick.AddListener(delegate + { + SetValue(CastDigitalNumber(Value) - delta); + RefreshFormatValue(Value); + }); + } + + #endregion + + #region ʵ + + protected override void SetValue(object newValue) + { + base.SetValue(CastDigitalNumber(newValue, minValue, maxValue, digits)); + } + + public override void RefreshValueWithoutEvent(object newValue, bool forceSet = false) + { + base.RefreshValueWithoutEvent(CastDigitalNumber(newValue, minValue, maxValue, digits), forceSet); + } + + protected override void Initialization_ChildConstruction(UIBehaviour component) + { + base.Initialization_ChildConstruction(component); + + + if (component is TMP_InputField inputField) + { + if (targetInput != null) + targetInput = inputField; + } + else if(component is Button button) + { + var name = component.transform.name; + switch (name) + { + case "subbutton": + case "SubButton": + if (digitalSubButton != null) + digitalSubButton = button; + break; + case "addbutton": + case "AddButton": + if (digitalAddButton != null) + digitalAddButton = button; + break; + } + } + } + + protected override void RefreshFormatValue(object newValue) + { + base.RefreshFormatValue(newValue); + targetInput.text = CastDigitalNumber(newValue).ToString(numberFormat); + } + + #endregion + } +} diff --git a/ConfigUIElement/Scripts/Element/ConfigDropdown.cs b/ConfigUIElement/Scripts/Element/ConfigDropdown.cs new file mode 100644 index 0000000..0086ea1 --- /dev/null +++ b/ConfigUIElement/Scripts/Element/ConfigDropdown.cs @@ -0,0 +1,78 @@ +using System.Collections; +using System.Collections.Generic; +using System.Linq; +using TMPro; +using UnityEngine; +using UnityEngine.EventSystems; +using UnityEngine.Serialization; +using UnityEngine.UI; + +namespace LRC +{ + public class ConfigDropdown : ConfigSelectableItem + { + #region ֶ + + public TMP_Dropdown targetDropdown; + + #endregion + + #region + + protected override void Awake() + { + base.Awake(); + targetDropdown.onValueChanged.AddListener(index => + { + SetValue(index); + }); + } + + public void InitializationDropdown(IEnumerable options) + { + targetDropdown.options = options + .Select(option => new TMP_Dropdown.OptionData(option)).ToList(); + targetDropdown.RefreshShownValue(); + if (IsValueInitNull) + RefreshValueWithoutEvent(0); + } + + #endregion + + #region ʵ + + protected override void SetValue(object newValue) + { + base.SetValue(CastIntNumber(newValue)); + } + + public override void RefreshValueWithoutEvent(object newValue, bool forceSet = false) + { + base.RefreshValueWithoutEvent(CastIntNumber(newValue), forceSet); + } + + protected override void Initialization_ChildConstruction(UIBehaviour component) + { + base.Initialization_ChildConstruction(component); + + var name = component.transform.name; + if (name is not "dropdown") return; + if (component is TMP_Dropdown dropdown) + { + if (targetDropdown != null) + targetDropdown = dropdown; + } + } + + protected override void RefreshFormatValue(object newValue) + { + base.RefreshFormatValue(newValue); + if (newValue == null) + return; + targetDropdown.value = CastIntNumber(newValue); + targetDropdown.RefreshShownValue(); + } + + #endregion + } +} \ No newline at end of file diff --git a/ConfigUIElement/Scripts/Element/ConfigSelectableItem.cs b/ConfigUIElement/Scripts/Element/ConfigSelectableItem.cs new file mode 100644 index 0000000..72221bf --- /dev/null +++ b/ConfigUIElement/Scripts/Element/ConfigSelectableItem.cs @@ -0,0 +1,712 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.Reflection; +using TMPro; +using UnityEngine; +using UnityEngine.EventSystems; +using UnityEngine.Serialization; +using UnityEngine.UI; +using XericLibrary.Runtime.CustomEditor; +using XericLibrary.Runtime.MacroLibrary; + +namespace LRC +{ + /// + /// һڻĿ + /// + /// ڴṩ˫ί޸ģӵǡ + /// ڳʼʱΪȡ + /// ǽ״ηıʱм¼Ӱֵ + /// + /// + public abstract class ConfigSelectableItem : MonoBehaviour + { + #region ̬¼ + + private static event Action ForceUpdateAllConfigEvent; + /// + /// ǿмijԱµ¼ʼʱⲿʱ + /// + /// + public static void ForceUpdateAll(bool resetDirty = false, bool forceSet = false) + { + ForceUpdateAllConfigEvent?.Invoke(resetDirty, forceSet); + } + + private static event Action ForceSetAllSourceValueEvent; + /// + /// ǿмijԱõ¼簴Ӧðťʱ + /// + public static void ForceSetAllSourceValue() + { + ForceSetAllSourceValueEvent?.Invoke(); + } + + /// + /// ֵ⵽޸ʱ + /// + public static event Action OnAnyValueDirty; + + /// + /// ֵյ޸ʱ¼ֵĺ޸ǰֵ + /// + public static event Action OnAnyValueChange; + + #endregion + + #region ̬Ա + + /// + /// ЧĿĿأڼ״̬ʱͻбɾ + /// + private static readonly List ConfigItemList = new List(); + + /// + /// ĿбЧԱ + /// + public static int ConfigItemListCount => ConfigItemList.Count; + + /// + /// ȡ + /// + /// + /// + public static ConfigSelectableItem GetConfigItemByIndex(int index) => ConfigItemList[index]; + public static IEnumerable ConfigItemLists => ConfigItemList; + + private static bool autoUpdateValueAll; + /// + /// Զֵ + /// + public static bool AutoUpdateValueAll + { + get => autoUpdateValueAll; + set + { + foreach (var item in ConfigItemList) + item.autoUpdateValue = value; + autoUpdateValueAll = value; + } + } + + #endregion + + #region ״̬ + + /// + /// ֵ⵽޸ʱ࣬ںӦпԱı仯 + /// + /// 飺ǿѡ + /// ̷ֵ޸ʱұOnValueChange磬ڸλ֮ǰֻһΡ + /// + /// + public event Action OnValueDirty; + + /// + /// ֵյ޸ʱ¼ֵĺ޸ǰֵ + /// + /// 飺ǿѡ + /// ̷ֵ޸ʱҪҳˢµĻеȴ + /// + /// + public event Action OnValueChange; + + /// + /// ֵ޸ʱ + /// + public event Action OnEndEdit; + /// + /// ǰȡֵ + /// + /// 飺DZҪ + /// ˢ¼ʱá + /// ǽⲿֵ趨ˡ + /// + /// + public event Func GetSourceValue; + + /// + /// ǰֵ + /// + /// 飺DZҪ + /// ӦʱForceSetAllSourceValueá + /// ǽ˴ĽֵصС + /// 棺ҪForceSetAllSourceValueSetSourceValueRequestȷ + /// ѭԼڴ⡣ + /// + /// + public event Action SetSourceValue; + + /// + /// ǰԵԶȡ + /// + /// 飺ѡ + /// ĿдToggleʱ(ӦautoUpdateValueToggleĿ) + /// ˴ڴⲿֵǷѡֵ趨 + /// + /// + public event Func GetSourceValueAutoUpdate; + + /// + /// ǰԵԶ + /// + /// 飺ѡ + /// ĿдToggleʱ(ӦautoUpdateValueToggleĿ) + /// ˴õⲿǷѡֵ趨 + /// + /// + public event Action SetSourceValueAutoUpdate; + + + + /// + /// ֵ(ֵӦõĴ) + /// + public void SetSourceValueRequest() + { + SetSourceValue?.Invoke(this, Value); + } + + #endregion + + #region ֶ + + /// + /// ĿӦıtag + /// + [Rename("ӳ")] + public string configTag; + + /// + /// 趨ǷЧ + /// Ч + /// + [SerializeField] + [Rename("")] + private bool allowInput = true; + + /// + /// Զֵ + /// + [SerializeField] + [Rename("")] + private bool autoUpdateValue = true; + + /// + /// Զ£ʾĿԶ״̬ѡ״̬ + /// + [SerializeField] + [Rename("Զ")] + private bool allowBlockUpdate = true; + + /// + /// Զ£һɳԶݽ + /// + [SerializeField] + [Rename("Զ")] + private bool forceBlockUpdate = false; + + /// + /// ʽı + /// + public string numberFormat = "0.##"; + + /// + /// Ŀ + /// + public TextMeshProUGUI titleLabel; +#if UNITY_EDITOR + [SerializeField] +#endif + private string titleTextContext; + + /// + /// ı + /// + public TextMeshProUGUI helpLabel; +#if UNITY_EDITOR + [SerializeField] +#endif + private string helpTextContext; + + /// + /// λı + /// + public TextMeshProUGUI unitLabel; +#if UNITY_EDITOR + [SerializeField] +#endif + private string unitTextContext; + + /// + /// ĿǰѡautoUpdateValueӦ + /// + [Rename("Զ״̬ѡ")] + public Toggle autoUpdateValueToggle; + + /// + /// תѡ״̬ + /// + [Rename("תԶ°ť״̬")] + public bool autoUpdateValueToggleReversalState; + + [Rename("תԶ״̬")] + public bool autoUpdateValueReversalState; + + /// + /// Զλ + /// Ա¿ʱȡ״̬ + /// + [Rename("Զλ")] + public bool dirtyAutoReset = false; + + // ==== ==== // + + /// + /// 趨ǷЧ + /// + public virtual bool AllowInput + { + get => allowInput; + set => allowInput = value; + } + + /// + /// ĿѾʼ + /// + [HideInInspector] + public bool IsValueInitNull { get; private set; } = true; + + // [Obsolete("ʹ÷")] + private bool _isDirty; + /// + /// Աǣ״й㲥 + /// + private bool IsDirty + { + get => _isDirty; + set + { + if (_isDirty) + { + if (!value) + _isDirty = false; + return; + } + if (!value) return; + + _isDirty = true; + OnAnyValueDirty?.Invoke(this); + OnValueDirty?.Invoke(this); + } + } + + /// + /// 趨Զ״̬ͬѡ + /// + /// Ϊд㣬״̬Ǻⲿݴֵһ£ + /// ˷Ϊ״̬ı׼ʡ + /// + /// ʽԶת򲻽ת + /// Ӧʹô˷ûڲʣⲿͨѶӦʹֶΡ + /// + /// Ҫڲж״̬תΪ״̬ + /// ӦͨautoUpdateValueReversalStateתΪݴֵ + /// ȻͨautoUpdateValueToggleReversalStateתΪֵ + /// + /// + public bool AutoUpdateValue + { + get => autoUpdateValueReversalState ^ autoUpdateValue; + set + { + autoUpdateValue = value; + if (autoUpdateValueToggle != null) + autoUpdateValueToggle.isOn = autoUpdateValueToggleReversalState ^ value; + } + } + + /// + /// 趨Զ + /// + public bool ForceBlockUpdate + { + get => forceBlockUpdate; + set => forceBlockUpdate = value; + } + + /// + /// Ŀ + /// + public string TitleName + { + get => titleLabel.text; + set => titleLabel.text = value; + } + + /// + /// ıĬӦDzʾͨıرʾ + /// + public string HelpName + { + get + { + if (helpLabel != null) return helpLabel.text; + return null; + } + set + { + if (helpLabel != null) + { + if (value != null) + { + helpLabel.text = value; + helpLabel.gameObject.SetActive(true); + } + else + helpLabel.gameObject.SetActive(false); + } + } + } + + public string UnitName + { + get => unitLabel.text; + set => unitLabel.text = value; + } + + [SerializeField] + // [Obsolete("ʹ÷")] + private object _value; + + /// + /// Ŀֵ + /// + public object Value + { + get => _value; + protected set + { + if (IsValueInitNull && value != null) + IsValueInitNull = false; + _value = value; + } + } + + // ==== ݴ ==== // + + public FieldInfo FieldInfo; + + public Type FieldType; + + #endregion + + #region + + protected virtual void OnValidate() + { + if (titleLabel != null) + TitleName = titleTextContext; + if (helpLabel != null) + HelpName = helpTextContext; + if (unitLabel != null) + UnitName = unitTextContext; + } + + protected virtual void Awake() + { + foreach (var child in transform.GetChildren()) + { + var component = child.GetComponent(); + if (component != null) + Initialization_ChildConstruction(component); + } + + Initialization_EventBinding(); + } + + protected virtual void OnEnable() + { + ConfigItemList.Add(this); + ForceUpdateAllConfigEvent += ForceUpdate; + ForceSetAllSourceValueEvent += SetSourceValueRequest; + + if (dirtyAutoReset) + IsDirty = false; + } + + protected virtual void OnDisable() + { + ConfigItemList.Remove(this); + ForceUpdateAllConfigEvent -= ForceUpdate; + ForceSetAllSourceValueEvent -= SetSourceValueRequest; + } + + protected virtual void Start() + { + ForceUpdate(true); + } + + private void Update() + { + if (IsValueInitNull || (AutoUpdateValue && !(allowBlockUpdate && forceBlockUpdate))) + { + ForceUpdate(); + } + } + + private void OnDestroy() + { + ForceUpdateAllConfigEvent -= ForceUpdate; + } + + #endregion + + #region ת + + protected static double CastDigitalNumber(object newValue) + { + if (double.TryParse(newValue.ToString(), out var value)) + { + return value; + } + return -1; + } + + /// + /// תֵֵͣǯ룩 + /// + /// + /// + /// + /// + /// + protected static double CastDigitalNumber(object newValue, double minValue, double maxValue, int digits) + { + // var resultValue = newValue switch + // { + // bool boolValue => boolValue ? 1 : 0, + // short intValue => intValue, + // int intValue => intValue, + // long intValue => intValue, + // float floatValue => Math.Round(floatValue, digits), + // double doubleValue => Math.Round(doubleValue, digits), + // _ => 0 + // }; +#if UNITY_EDITOR + if (newValue == null) + { + Debug.LogError($"ת:Ŀһֵڷֵʱǰ˳"); + return -1; + } +#endif + if (double.TryParse(newValue.ToString(), out var value)) + { + var resultValue = Math.Round(value, digits); + return Math.Clamp(resultValue, minValue, maxValue); + } + Debug.LogError($"ת:{newValue}ܲһЧֵ"); + return -1; + } + + protected static int CastIntNumber(object newValue) + { + var resultValue = Convert.ToInt32(newValue); + return resultValue; + } + + protected static Vector2 CastVector2(object newValue) + { + return newValue switch + { + Vector2 vec2Value => vec2Value, + System.Numerics.Vector2 sysVec2Value => new Vector2(sysVec2Value.X, sysVec2Value.Y), + _ => Vector2.zero + }; + } + + protected static Vector3 CastVector3(object newValue) + { + return newValue switch + { + Vector3 vec3Value => vec3Value, + System.Numerics.Vector3 sysVec3Value => new Vector3(sysVec3Value.X, sysVec3Value.Y, sysVec3Value.Z), + _ => Vector3.zero + }; + } + + #endregion + + #region ʼ + + /// + /// ѡĻʼ + /// + /// 趨Զ + protected void Initialization(bool autoUpdateValue = true) + { + AutoUpdateValue = autoUpdateValue; + } + + private bool _doOnce = false; + /// + /// ԣڳʼУͨʶĿ + /// + protected virtual void Initialization_ChildConstruction(UIBehaviour component) + { + // ٽڵ + var name = component.gameObject.name; + // ʼԶ¶Թ + if (name == "toggle" && component is Toggle toggle) + { + if (autoUpdateValueToggle == null) + autoUpdateValueToggle = toggle; + return; + } + if (name is not ("title" or "name")) return; + if (_doOnce) + { + Debug.LogError("ظģ飺" + name); + return; + } + if (component is TextMeshProUGUI textMeshProUGUI) + { + _doOnce = true; + if (titleLabel != null) + titleLabel = textMeshProUGUI; + } + } + + /// + /// ¼ڳʼǰҪж̬󶨵ݼ + /// + protected virtual void Initialization_EventBinding() + { + // Σ¼Ҫע + if (autoUpdateValueToggle != null) + { + autoUpdateValueToggle.onValueChanged.AddListener(a => + { + autoUpdateValue = autoUpdateValueToggleReversalState ^ a; + // Զתʹֶ + SetSourceValueAutoUpdate?.Invoke(autoUpdateValue); + // ܲ + // OnValueDirty?.Invoke(this); + }); + } + } + + #endregion + + #region · + + /// + /// º + /// + /// ʱ̵ʱǿˢеĹܣѾ򲻻κΪ + /// ָӱи£ֵ̲ȡص + /// + /// + public virtual void ForceUpdate(bool resetDirty = false, bool forceSet = false) + { + if (resetDirty) + IsDirty = false; + var value = GetSourceValue?.Invoke(this); + if (value == null) + return ; + RefreshValueWithoutEvent(value, forceSet); + RefreshAutoUpdateValue(); + } + + /// + /// ֵ¼ͨɽ淢Բ½ + /// + /// + protected virtual void SetValue(object newValue) + { + if (Value == newValue) + return; + var lastValue = Value; + // 룬λΪڵֵ + if (!allowInput) + RefreshValueWithoutEvent(Value); + else + { + Value = newValue; + IsDirty = true; + + OnAnyValueChange?.Invoke(this, lastValue); + OnValueChange?.Invoke(this, lastValue); + } + } + + /// + /// ֵʱ¼Ӧýнֵ¡ + /// + /// + /// + public virtual void RefreshValueWithoutEvent(object newValue, bool forceSet = false) + { + if (!AutoUpdateValue && !forceSet) + return; + if (newValue == null) + return; + if (Value != null && (Value.ToString() == newValue.ToString())) + return; + Value = newValue; + RefreshFormatValue(newValue); + } + + /// + /// Զ״̬ + /// + protected void RefreshAutoUpdateValue() + { + var isSourceValueAutoUpdate = GetSourceValueAutoUpdate?.Invoke(this); + if (isSourceValueAutoUpdate != null) + AutoUpdateValue = isSourceValueAutoUpdate.Value; + } + + /// + /// ˢ¸ʽıڴˢʱ + /// + protected virtual void RefreshFormatValue(object newValue) + { + + } + + protected void WhenStartEdit() + { + // Debug.Log("ʼ༭"); + ForceBlockUpdate = true; + } + + /// + /// ֵϣ򽹵Ƴʱá + /// + protected void WhenEndEdit() + { + // Debug.Log("༭"); + ForceBlockUpdate = false; + OnEndEdit?.Invoke(this, Value); + } + + #endregion + + #region 趨 + + /// + /// Զ¸ѡ򣬲趨ǰǷԶ + /// + /// + public void DestroyAutoUpdateValue(bool autoUpdateValue) + { + Destroy(autoUpdateValueToggle.gameObject); + this.autoUpdateValue = autoUpdateValueReversalState ^ autoUpdateValue; + } + + #endregion + + } +} \ No newline at end of file diff --git a/ConfigUIElement/Scripts/Element/ConfigTextInputField.cs b/ConfigUIElement/Scripts/Element/ConfigTextInputField.cs new file mode 100644 index 0000000..0db11a9 --- /dev/null +++ b/ConfigUIElement/Scripts/Element/ConfigTextInputField.cs @@ -0,0 +1,100 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using TMPro; +using UnityEngine; +using UnityEngine.EventSystems; +using UnityEngine.UI; + +namespace LRC +{ + /// + /// һͨı + /// + public class ConfigTextInputField : ConfigSelectableItem + { + #region ֶ + +#if UNITY_EDITOR + public string editorInput; +#endif + + public TMP_InputField targetInput; + + + public override bool AllowInput + { + get => base.AllowInput; + set + { + if (targetInput != null) + targetInput.readOnly = !value; + base.AllowInput = value; + } + } + + #endregion + + #region + + protected override void OnValidate() + { + base.OnValidate(); +#if UNITY_EDITOR + if (targetInput != null) + targetInput.text = editorInput; +#endif + } + + protected override void Awake() + { + base.Awake(); + targetInput.onSelect.AddListener(a => + { + WhenStartEdit(); + }); + targetInput.onValueChanged.AddListener(o => + { + if(double.TryParse(o, out var value)) + SetValue(value); + }); + targetInput.onEndEdit.AddListener(delegate + { + WhenEndEdit(); + }); + } + + #endregion + + #region ʵ + + protected override void SetValue(object newValue) + { + base.SetValue(newValue); + } + + public override void RefreshValueWithoutEvent(object newValue, bool forceSet = false) + { + base.RefreshValueWithoutEvent(newValue, forceSet); + } + + protected override void Initialization_ChildConstruction(UIBehaviour component) + { + base.Initialization_ChildConstruction(component); + + if (component is TMP_InputField inputField) + { + if (targetInput != null) + targetInput = inputField; + } + } + + protected override void RefreshFormatValue(object newValue) + { + base.RefreshFormatValue(newValue); + targetInput.text = newValue.ToString(); + } + + #endregion + } +} diff --git a/ConfigUIElement/Scripts/Element/ConfigToggleGroup.cs b/ConfigUIElement/Scripts/Element/ConfigToggleGroup.cs new file mode 100644 index 0000000..d795027 --- /dev/null +++ b/ConfigUIElement/Scripts/Element/ConfigToggleGroup.cs @@ -0,0 +1,86 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using UnityEngine; +using UnityEngine.EventSystems; +using UnityEngine.Serialization; +using UnityEngine.UI; + +namespace LRC +{ + /// + /// ѡ飬һǰЧѡΪֵ + /// + public class ConfigToggleGroup : ConfigSelectableItem + { + #region ֶ + + public ToggleGroup targetToggle; + + public List toggles; + + #endregion + + #region + + protected override void Awake() + { + base.Awake(); + + for (int i = 0; i < toggles.Count; i++) + { + void BuildInGroupInit() + { + var index = i; + var toggle = toggles[i]; + toggle.onValueChanged.AddListener(a => + { + if (a) + SetValue(index); + }); + } + BuildInGroupInit(); + } + } + + #endregion + + #region ʵ + + protected override void SetValue(object newValue) + { + base.SetValue(CastIntNumber(newValue)); + } + + public override void RefreshValueWithoutEvent(object newValue, bool forceSet = false) + { + base.RefreshValueWithoutEvent(CastIntNumber(newValue), forceSet); + } + + protected override void Initialization_ChildConstruction(UIBehaviour component) + { + base.Initialization_ChildConstruction(component); + + if (component is Toggle toggle && + !toggles.Contains(toggle)) + toggles.Add(toggle); + } + + protected override void RefreshFormatValue(object newValue) + { + base.RefreshFormatValue(newValue); + var newIndex = CastIntNumber(newValue); + // var index = 0; + // foreach (var toggle in targetToggle.ActiveToggles()) + // { + // if (newIndex != index++) + // continue; + // toggle.isOn = true; + // Debug.Log(TitleName +":òĿ"); + // } + toggles[newIndex].SetIsOnWithoutNotify(true); + } + + #endregion + } +} \ No newline at end of file diff --git a/ConfigUIElement/Scripts/Element/ConfigTypeOverrideAttribute.cs b/ConfigUIElement/Scripts/Element/ConfigTypeOverrideAttribute.cs new file mode 100644 index 0000000..8ee1393 --- /dev/null +++ b/ConfigUIElement/Scripts/Element/ConfigTypeOverrideAttribute.cs @@ -0,0 +1,38 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.Reflection; +using UnityEngine; + +namespace LRC +{ + [AttributeUsage(AttributeTargets.Field)] + public class ConfigTypeOverrideAttribute : PropertyAttribute + { + public readonly string TypeName; + + public ConfigTypeOverrideAttribute(string name) + { + TypeName = name; + } + + /// + /// Իȡеrename + /// + /// + /// ͨԻȡƣûΪԭ + /// ǷɹͨԻȡƣͨ + public static bool TryGetMemberName(FieldInfo field, out string name) + { + if (field.GetCustomAttribute(typeof(ConfigTypeOverrideAttribute)) is ConfigTypeOverrideAttribute rename) + { + name = rename.TypeName; + return true; + } + + name = field.FieldType.Name; + return false; + } + + } +} \ No newline at end of file diff --git a/ConfigUIElement/Scripts/Element/ConfigVec2InputField.cs b/ConfigUIElement/Scripts/Element/ConfigVec2InputField.cs new file mode 100644 index 0000000..68f6078 --- /dev/null +++ b/ConfigUIElement/Scripts/Element/ConfigVec2InputField.cs @@ -0,0 +1,129 @@ +using System.Collections; +using System.Collections.Generic; +using UnityEngine; +using TMPro; +using UnityEngine.EventSystems; +using UnityEngine.UI; + +namespace LRC +{ + public class ConfigVec2InputField : ConfigSelectableItem + { + #region ֶ + +#if UNITY_EDITOR + public Vector2 editorInput; +#endif + + public TMP_InputField targetInputX; + public TMP_InputField targetInputY; + + public override bool AllowInput + { + get => base.AllowInput; + set + { + if (targetInputX != null) + targetInputX.readOnly = !value; + if (targetInputY != null) + targetInputY.readOnly = value; + base.AllowInput = value; + } + } + + #endregion + + #region + protected override void OnValidate() + { + base.OnValidate(); +#if UNITY_EDITOR + if (targetInputX != null) + targetInputX.text = editorInput.x.ToString(); + if (targetInputY != null) + targetInputY.text = editorInput.y.ToString(); +#endif + } + protected override void Awake() + { + base.Awake(); + + targetInputX.onSelect.AddListener(a => + { + WhenStartEdit(); + }); + targetInputY.onSelect.AddListener(a => + { + WhenStartEdit(); + }); + targetInputX.onValueChanged.AddListener(a => + { + var value = CastVector3(Value); + value.x = float.Parse(a); + SetValue(value); + }); + targetInputY.onValueChanged.AddListener(a => + { + var value = CastVector3(Value); + value.y = float.Parse(a); + SetValue(value); + }); + targetInputX.onEndEdit.AddListener(delegate + { + WhenEndEdit(); + }); + targetInputY.onEndEdit.AddListener(delegate + { + WhenEndEdit(); + }); + } + + #endregion + + #region ʵ + + protected override void SetValue(object newValue) + { + base.SetValue(CastVector2(newValue)); + } + + public override void RefreshValueWithoutEvent(object newValue, bool forceSet = false) + { + base.RefreshValueWithoutEvent(CastVector2(newValue), forceSet); + } + + protected override void Initialization_ChildConstruction(UIBehaviour component) + { + base.Initialization_ChildConstruction(component); + + var name = component.transform.name; + if (component is not TMP_InputField inputField) + return; + switch (name) + { + case "inputx": + case "inputX": + if (targetInputX != null) + targetInputX = inputField; + break; + case "inputy": + case "inputY": + if (targetInputY != null) + targetInputY = inputField; + break; + default: + break; + } + } + + protected override void RefreshFormatValue(object newValue) + { + base.RefreshFormatValue(newValue); + var value = CastVector2(newValue); + targetInputX.text = value.x.ToString(numberFormat); + targetInputY.text = value.y.ToString(numberFormat); + } + + #endregion + } +} \ No newline at end of file diff --git a/ConfigUIElement/Scripts/Element/ConfigVec3InputField.cs b/ConfigUIElement/Scripts/Element/ConfigVec3InputField.cs new file mode 100644 index 0000000..af55352 --- /dev/null +++ b/ConfigUIElement/Scripts/Element/ConfigVec3InputField.cs @@ -0,0 +1,158 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using UnityEngine; +using TMPro; +using UnityEngine.EventSystems; +using UnityEngine.UI; + +namespace LRC +{ + + public class ConfigVec3InputField : ConfigSelectableItem + { + #region ֶ + +#if UNITY_EDITOR + public Vector3 editorInput; +#endif + + public TMP_InputField targetInputX; + public TMP_InputField targetInputY; + public TMP_InputField targetInputZ; + + public override bool AllowInput + { + get => base.AllowInput; + set + { + if (targetInputX != null) + targetInputX.readOnly = !value; + if (targetInputY != null) + targetInputY.readOnly = value; + if (targetInputZ != null) + targetInputZ.readOnly = value; + base.AllowInput = value; + } + } + + #endregion + + #region + + protected override void OnValidate() + { + base.OnValidate(); +#if UNITY_EDITOR + if (targetInputX != null) + targetInputX.text = editorInput.x.ToString(); + if (targetInputY != null) + targetInputY.text = editorInput.y.ToString(); + if (targetInputZ != null) + targetInputZ.text = editorInput.z.ToString(); +#endif + } + + protected override void Awake() + { + base.Awake(); + + targetInputX.onSelect.AddListener(a => + { + WhenStartEdit(); + }); + targetInputY.onSelect.AddListener(a => + { + WhenStartEdit(); + }); + targetInputZ.onSelect.AddListener(a => + { + WhenStartEdit(); + }); + targetInputX.onValueChanged.AddListener(a => + { + var value = CastVector3(Value); + value.x = float.Parse(a); + SetValue(value); + }); + targetInputY.onValueChanged.AddListener(a => + { + var value = CastVector3(Value); + value.y = float.Parse(a); + SetValue(value); + }); + targetInputZ.onValueChanged.AddListener(a => + { + var value = CastVector3(Value); + value.z = float.Parse(a); + SetValue(value); + }); + targetInputX.onEndEdit.AddListener(delegate + { + WhenEndEdit(); + }); + targetInputY.onEndEdit.AddListener(delegate + { + WhenEndEdit(); + }); + targetInputZ.onEndEdit.AddListener(delegate + { + WhenEndEdit(); + }); + } + + #endregion + + #region ʵ + + protected override void SetValue(object newValue) + { + base.SetValue(CastVector3(newValue)); + } + + public override void RefreshValueWithoutEvent(object newValue, bool forceSet = false) + { + base.RefreshValueWithoutEvent(CastVector3(newValue), forceSet); + } + + protected override void Initialization_ChildConstruction(UIBehaviour component) + { + base.Initialization_ChildConstruction(component); + + var name = component.transform.name; + if (component is not TMP_InputField inputField) + return; + switch (name) + { + case "inputx": + case "inputX": + if (targetInputX != null) + targetInputX = inputField; + break; + case "inputy": + case "inputY": + if (targetInputY != null) + targetInputY = inputField; + break; + case "inputz": + case "inputZ": + if (targetInputZ != null) + targetInputZ = inputField; + break; + default: + break; + } + } + + protected override void RefreshFormatValue(object newValue) + { + base.RefreshFormatValue(newValue); + var value = CastVector3(newValue); + targetInputX.text = value.x.ToString(numberFormat); + targetInputY.text = value.y.ToString(numberFormat); + targetInputZ.text = value.z.ToString(numberFormat); + } + + #endregion + } +} \ No newline at end of file diff --git a/Documentation/Sesotho Line.md b/Documentation/Sesotho Line.md new file mode 100644 index 0000000..6f65ddd --- /dev/null +++ b/Documentation/Sesotho Line.md @@ -0,0 +1,169 @@ +>>> +**_Package Documentation Template_** + +Use this template to create preliminary, high-level documentation meant to introduce users to the feature and the sample files included in this package. When writing your documentation, do the following: + +1. Follow instructions in blockquotes. + +2. Replace angle brackets with the appropriate text. For example, replace "<package name>" with the official name of the package. + +3. Delete sections that do not apply to your package. For example, a package containing only sample files does not have a "Using <package_name>" section, so this section can be removed. + +4. After documentation is completed, make sure you delete all instructions and examples in blockquotes including this preamble and its title: + + ``` + >>> + Delete all of the text between pairs of blockquote markdown. + >>> + ``` +>>> + +# About <package name> + +>>> +Name the heading of the first topic after the **displayName** of the package as it appears in the package manifest. + +This first topic includes a brief, high-level explanation of the package and, if applicable, provides links to Unity Manual topics. + +There are two types of packages: + + - Packages that include features that augment the Unity Editor or Runtime. + - Packages that include sample files. + +Choose one of the following introductory paragraphs that best fits the package: +>>> + +Use the <package name> package to <list of the main uses for the package>. For example, use <package name> to create/generate/extend/capture <mention major use case, or a good example of what the package can be used for>. The <package name> package also includes <other relevant features or uses>. + +> *or* + +The <package name> package includes examples of <name of asset type, model, prefabs, and/or other GameObjects in the package>. For more information, see <xref to topic in the Unity Manual>. + +>>> +**_Examples:_** + +Here are some examples for reference only. Do not include these in the final documentation file: + +*Use the Unity Recorder package to capture and save in-game data. For example, use Unity Recorder to record an mp4 file during a game session. The Unity Recorder package also includes an interface for setting-up and triggering recording sessions.* + +*The Timeline Examples package includes examples of Timeline assets, Timeline Instances, animation, GameObjects, and scripts that illustrate how to use Unity's Timeline. For more information, see [ Unity's Timeline](https://docs.unity3d.com/Manual/TimelineSection.html) in the [Unity Manual](https://docs.unity3d.com). For licensing and usage, see Package Licensing.* +>>> + +# Installing <package name> +>>> +Begin this section with a cross-reference to the official Unity Manual topic on how to install packages. If the package requires special installation instructions, include these steps in this section. +>>> + +To install this package, follow the instructions in the [Package Manager documentation](https://docs.unity3d.com/Packages/com.unity.package-manager-ui@latest/index.html). + +>>> +For some packages, there may be additional steps to complete the setup. You can add those here. +>>> + +In addition, you need to install the following resources: + + - <name of resource>: To install, open *Window > <name of menu item>*. The resource appears <at this location>. + - <name of sample>: To install, open *Window > <name of menu item>*. The new sample folder appears <at this location>. + + + +# Using <package name> +>>> +The contents of this section depends on the type of package. + +For packages that augment the Unity Editor with additional features, this section should include workflow and/or reference documentation: + +* At a minimum, this section should include reference documentation that describes the windows, editors, and properties that the package adds to Unity. This reference documentation should include screen grabs (see how to add screens below), a list of settings, an explanation of what each setting does, and the default values of each setting. +* Ideally, this section should also include a workflow: a list of steps that the user can easily follow that demonstrates how to use the feature. This list of steps should include screen grabs (see how to add screens below) to better describe how to use the feature. + +For packages that include sample files, this section may include detailed information on how the user can use these sample files in their projects and scenes. However, workflow diagrams or illustrations could be included if deemed appropriate. + +## How to add images + +*(This section is for reference. Do not include in the final documentation file)* + +If the [Using <package name>](#UsingPackageName) section includes screen grabs or diagrams, a link to the image must be added to this MD file, before or after the paragraph with the instruction or description that references the image. In addition, a caption should be added to the image link that includes the name of the screen or diagram. All images must be PNG files with underscores for spaces. No animated GIFs. + +An example is included below: + +![A cinematic in the Timeline Editor window.](images/example.png) + +Notice that the example screen shot is included in the images folder. All screen grabs and/or diagrams must be added and referenced from the images folder. + +For more on the Unity documentation standards for creating and adding screen grabs, see this confluence page: https://confluence.hq.unity3d.com/pages/viewpage.action?pageId=13500715 +>>> + + + +# Technical details +## Requirements +>>> +This subtopic includes a bullet list with the compatible versions of Unity. This subtopic may also include additional requirements or recommendations for 3rd party software or hardware. An example includes a dependency on other packages. If you need to include references to non-Unity products, make sure you refer to these products correctly and that all references include the proper trademarks (tm or r) +>>> + +This version of <package name> is compatible with the following versions of the Unity Editor: + +* 2018.1 and later (recommended) + +To use this package, you must have the following 3rd party products: + +* <product name and version with trademark or registered trademark.> +* <product name and version with trademark or registered trademark.> +* <product name and version with trademark or registered trademark.> + +## Known limitations +>>> +This section lists the known limitations with this version of the package. If there are no known limitations, or if the limitations are trivial, exclude this section. An example is provided. +>>> + +<package name> version <package version> includes the following known limitations: + +* <brief one-line description of first limitation.> +* <brief one-line description of second limitation.> +* <and so on> + +>>> +*Example (For reference. Do not include in the final documentation file):* + +The Unity Recorder version 1.0 has the following limitations:* + +* The Unity Recorder does not support sound. +* The Recorder window and Recorder properties are not available in standalone players. +* MP4 encoding is only available on Windows. +>>> + +## Package contents +>>> +This section includes the location of important files you want the user to know about. For example, if this is a sample package containing textures, models, and materials separated by sample group, you may want to provide the folder location of each group. +>>> + +The following table indicates the <describe the breakdown you used here>: + +|Location|Description| +|---|---| +|``|Contains <describe what the folder contains>.| +|``|Contains <describe what the file represents or implements>.| + +>>> +*Example (For reference. Do not include in the final documentation file):* + +The following table indicates the root folder of each type of sample in this package. Each sample's root folder contains its own Materials, Models, or Textures folders: + +|Folder Location|Description| +|---|---| +|`WoodenCrate_Orange`|Root folder containing the assets for the orange crates.| +|`WoodenCrate_Mahogany`|Root folder containing the assets for the mahogany crates.| +|`WoodenCrate_Shared`|Root folder containing any material assets shared by all crates.| +>>> + +## Document revision history +>>> +This section includes the revision history of the document. The revision history tracks when a document is created, edited, and updated. If you create or update a document, you must add a new row describing the revision. The Documentation Team also uses this table to track when a document is edited and its editing level. An example is provided: + +|Date|Reason| +|---|---| +|Sept 12, 2017|Unedited. Published to package.| +|Sept 10, 2017|Document updated for package version 1.1.
New features:
  • audio support for capturing MP4s.
  • Instructions on saving Recorder prefabs| +|Sept 5, 2017|Limited edit by Documentation Team. Published to package.| +|Aug 25, 2017|Document created. Matches package version 1.0.| +>>> \ No newline at end of file diff --git a/Documentation/images/Screenshot 2024-04-28 092352.jpg b/Documentation/images/Screenshot 2024-04-28 092352.jpg new file mode 100644 index 0000000000000000000000000000000000000000..94b52bf970248c4c55e01559b5e681cdb3396ebb GIT binary patch literal 215509 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

    bPM-+ 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 literal 0 HcmV?d00001 diff --git a/Editor/HorizonLineOrbit/SesothoPeManagerEditor.cs b/Editor/HorizonLineOrbit/SesothoPeManagerEditor.cs new file mode 100644 index 0000000..3c2e549 --- /dev/null +++ b/Editor/HorizonLineOrbit/SesothoPeManagerEditor.cs @@ -0,0 +1,154 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using UnityEditor; +using UnityEngine; +using UnityEngine.Serialization; + +namespace SesothoLine +{ + ///

    + /// ·Ʊ༭ + /// + [CustomEditor(typeof(SesothoPeManager))] + public class SesothoPeManagerEditor : Editor + { + #region ί¼ + + /// + /// ǰҪ궯 + /// + private event Action CurrenMouseAction; + + #endregion + + #region ֶ + + /// + /// DZ༭ģʽ + /// + public bool IsDebugDrawMode; + + private Vector3 _currentPosition; + + private bool OpKey_ForceStr; + private bool OpKey_90Arc; + private bool OpKey_180Arc; + private bool OpKey_RevCisoid; + + #endregion + + #region + + // private void OnEnable() + // { + // throw new NotImplementedException(); + // } + // + // private void OnDisable() + // { + // throw new NotImplementedException(); + // } + + private void OnSceneGUI() + { + if (!IsDebugDrawMode) return; + + int controlID = GUIUtility.GetControlID(FocusType.Keyboard); + if(GUIUtility.hotControl == 0) + HandleUtility.AddDefaultControl(controlID); + + OpKey_ForceStr = false; + OpKey_90Arc = false; + OpKey_180Arc = false; + OpKey_RevCisoid = false; + + if (Event.current.GetTypeForControl(controlID) == EventType.KeyDown) + { + switch (Event.current.keyCode) + { + case KeyCode.Escape: + IsDebugDrawMode = false; + break; + case KeyCode.LeftControl: + OpKey_ForceStr = true; + break; + case KeyCode.LeftAlt: + OpKey_90Arc = true; + break; + case KeyCode.LeftShift: + OpKey_180Arc = true; + break; + case KeyCode.R: + OpKey_RevCisoid = true; + break; + default: + break; + } + } + + var mousePos = Event.current.mousePosition; + if (Physics.Raycast(HandleUtility.GUIPointToWorldRay(mousePos), out var hit, float.MaxValue, 0xffff)) + { + _currentPosition = hit.point; + } + + if (Event.current.type == EventType.MouseUp && GUIUtility.hotControl == 0) + { + if (Event.current.button == 0) + { + CurrenMouseAction?.Invoke(); + } + } + } + + public override void OnInspectorGUI() + { + if (GUILayout.Button(IsDebugDrawMode ? "˳ģʽ" : "ģʽ")) + IsDebugDrawMode = !IsDebugDrawMode; + + base.OnInspectorGUI(); + } + + #endregion + + #region + + private TerminalLine2T3 _line; + private TerminalPoint _startPoint; + private TerminalPoint _endPoint; + + private void DarwLine() + { + _endPoint.transform.position = _currentPosition; + + // _line.SetLineSegment( + // _lastPointPosition, _currentPosition, + // _lastPointNormal, _helperNormal + // ); + + + if (OpKey_ForceStr) + _line.DrawStraightLine(); + else + { + var angle = -1; + if (OpKey_90Arc || OpKey_180Arc) + { + angle = 0; + if (OpKey_90Arc) + angle += 90; + if (OpKey_180Arc) + angle += 180; + } + _line.AutomaticDrawCircularLine(angle, OpKey_RevCisoid); + } + + // ϺִȾпܻ + // ڴ֮ǰĽ׶ѾԴ˽й˴ûйϵҪճĻҪһЩ޸ġ + _line.UpdateRender(); + } + + #endregion + } +} diff --git a/Editor/Lrss3.Deconstruction.Editor.asmdef b/Editor/Lrss3.Deconstruction.Editor.asmdef new file mode 100644 index 0000000..fe9718f --- /dev/null +++ b/Editor/Lrss3.Deconstruction.Editor.asmdef @@ -0,0 +1,19 @@ +{ + "name": "Lrss3.SesothoLine.Editor", + "rootNamespace": "SesothoLineEditor", + "references": [ + "Lrss3.SesothoLine", + "Lrss3.Deconstruction" + ], + "includePlatforms": [ + "Editor" + ], + "excludePlatforms": [], + "allowUnsafeCode": false, + "overrideReferences": false, + "precompiledReferences": [], + "autoReferenced": true, + "defineConstraints": [], + "versionDefines": [], + "noEngineReferences": false +} \ No newline at end of file diff --git a/Editor/UI/CircleSliderEditor.cs b/Editor/UI/CircleSliderEditor.cs new file mode 100644 index 0000000..e5b4aae --- /dev/null +++ b/Editor/UI/CircleSliderEditor.cs @@ -0,0 +1,73 @@ +using System.Collections; +using System.Collections.Generic; +using Deconstruction.Runtime.UI; +using UnityEditor; +using UnityEditor.UI; +using UnityEngine; + +namespace Deconstruction.Editor.UI +{ + +[CustomEditor(typeof(CircleSlider) , true)] +public class CircleSliderEditor : SelectableEditor +{ + private SerializedProperty m_Value; + private SerializedProperty FillOrigin; + private SerializedProperty m_MaxValue; + private SerializedProperty m_MinValue; + private SerializedProperty m_FillRect; + private SerializedProperty m_HandleRect; + private SerializedProperty m_FillOrigin; + private SerializedProperty m_Radius; + private SerializedProperty m_ClockWise; +// private SerializedProperty m_MaxAngle; +// private SerializedProperty m_MinAngle; + private SerializedProperty m_WholeNumbers; + + + protected override void OnEnable() + { + base.OnEnable(); + + m_FillRect = serializedObject.FindProperty("m_FillRect"); + m_HandleRect = serializedObject.FindProperty("m_HandleRect"); + m_MinValue = serializedObject.FindProperty("m_MinValue"); + m_MaxValue = serializedObject.FindProperty("m_MaxValue"); + m_Value = serializedObject.FindProperty("m_Value"); + m_FillOrigin = serializedObject.FindProperty("m_FillOrigin"); + m_Radius = serializedObject.FindProperty("m_Radius"); + m_ClockWise = serializedObject.FindProperty("m_ClockWise"); + m_WholeNumbers = serializedObject.FindProperty("m_WholeNumbers"); +// m_MaxAngle = serializedObject.FindProperty("m_MaxAngle"); +// m_MinAngle = serializedObject.FindProperty("m_MinAngle"); + + } + + public override void OnInspectorGUI() + { + base.OnInspectorGUI(); + serializedObject.Update(); + + EditorGUILayout.PropertyField(m_FillRect); + EditorGUILayout.PropertyField(m_HandleRect); + + if (m_FillRect.objectReferenceValue != null ) + { + EditorGUILayout.PropertyField(m_MinValue); + EditorGUILayout.PropertyField(m_MaxValue); + EditorGUILayout.PropertyField(m_WholeNumbers); + EditorGUILayout.Slider(m_Value, m_MinValue.floatValue, m_MaxValue.floatValue); + EditorGUILayout.PropertyField(m_FillOrigin); + EditorGUILayout.PropertyField(m_ClockWise); + } + + if (m_HandleRect.objectReferenceValue != null) + { + EditorGUILayout.PropertyField(m_Radius); + } + + serializedObject.ApplyModifiedProperties(); + } +} + +} \ No newline at end of file diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..c388945 --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2024 纸飞机 + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/LICENSE.meta b/LICENSE.meta new file mode 100644 index 0000000..c4273d1 --- /dev/null +++ b/LICENSE.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: ffdeedb95e1b528419119bc9a549a667 +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/README.en.md b/README.en.md new file mode 100644 index 0000000..4522a5f --- /dev/null +++ b/README.en.md @@ -0,0 +1,36 @@ +# SesothoLine + +#### Description +一种在unity中绘制线的插件，可以绘制直线与弧线，底层通过数学公式对线进行描述，无视线的分辨率，即可完成吸附，相交等操作。 + +#### Software Architecture +Software architecture description + +#### Installation + +1. xxxx +2. xxxx +3. xxxx + +#### Instructions + +1. xxxx +2. xxxx +3. xxxx + +#### Contribution + +1. Fork the repository +2. Create Feat_xxx branch +3. Commit your code +4. Create Pull Request + + +#### Gitee Feature + +1. You can use Readme\_XXX.md to support different languages, such as Readme\_en.md, Readme\_zh.md +2. Gitee blog [blog.gitee.com](https://blog.gitee.com) +3. Explore open source project [https://gitee.com/explore](https://gitee.com/explore) +4. The most valuable open source project [GVP](https://gitee.com/gvp) +5. The manual of Gitee [https://gitee.com/help](https://gitee.com/help) +6. The most popular members [https://gitee.com/gitee-stars/](https://gitee.com/gitee-stars/) diff --git a/README.en.md.meta b/README.en.md.meta new file mode 100644 index 0000000..961a27b --- /dev/null +++ b/README.en.md.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: eaa1bd9b1e9fc3749a09f1ae06a15627 +TextScriptImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/README.md b/README.md new file mode 100644 index 0000000..464968d --- /dev/null +++ b/README.md @@ -0,0 +1,314 @@ +# SesothoLine + +## 简介 + +unity通用库插件，现已转为unity 6000版本。 + +## 软件架构 + +* CentralizeLog: 小日志，unity本身的日志在调用时开销巨大，所以提供一个小日志的类型保存临时的日志内容。 +* Deconstruction: 通过数学公式对线进行描述，进行标准的CAD线路参数计算，并支持在线路上进行导航，合理性计算等 +* RescissionRework: 撤销重做 🕑 +* SerializerHelper: 序列化库 +* XericLibrary: 实用性unity宏库，包含一些实用扩展用法。 + +## Deconstruction + +Deconstruction 部分由两个dll组成，一个是 Deconstruction，另一个是 Deconstruction Style 。 + +### 线路绘制 +---- + + +线路绘制组件支持二维，或三维的线条计算，线条继承自“可放置物”类，为了能够显示线条，需要向其提供渲染器和，同理，为了能够算出构成线的点集合，需要提供线计算器。 +为此插件内默认提供了一个使用lineRenderer组件的线渲染器，以及二维的直线和圆弧的线计算器。 +在计算平面上的CAD线路时，通过实现二维的线计算器，并实现它的坐标转换方法，即可在任意表面上实现线的绘制与保存。 + +另外如果希望快速构建具有特制绘制规则的对象，则需要另外的可放置物管理器 PlaceElementManager ， +它继承于 SingleMonoBase ，所以可以通过单例的方式访问它。 + +可放置物管理器管理的是所有的可放置物对象，和决策工具类 DecisionMakerToolBase ，以及它们的生命周期。 + +工具类则提供了细致的针对如何放置对象的操作规则，并提供了操作栈表结构， +可以通过操作栈来实现具有链表关系的行为树，栈中的每个节点是行为树上的一个节点， +每个节点可以访问到上一个对象和下一个对象成员的节点。 + +每个节点可以是正在绘制的线，正在计算寻路的ai，或其他任何行为， +在节点内可以直接通过 ReplaceThis(new Exit_OpSlot()); 方法类来切换行为树的节点到一个新的节点。 + +* 基础规则 +建议在工具类中进行创建等操作，管理类中只进行管理操作，比如在插件的sesotho部分的非dll文件中，提供了SesothoPeManager和SesothoArrangementWiresTool，他们就是管理器与工具类的派生部分。 + +* 按键规则 +在没有任何工具启动的情况下，管理器可以接收按键输入，直到被工具输入抢占。 +不过，管理器到工具中并没有任何抢占逻辑，所以请根据工具激活逻辑适时关闭按键处理。 +另外，在没有任何工具激活的情况下，工具本身的按键获取机制也不会激活，记得使用原生的按键获取逻辑。 + +* 线路规则 + + +* 链路规则 +链路是指实现了IConterminousness接口的对象，这个接口提供了一个获取ICoterminous接口的访问器； +ICoterminous接口通常是用于实现链接关系的抽象层，简单的通过输入和输出来定义链接的线路，在接口中可以通过GetOpposite在当前对象的链接结构上下文中访问另一个与当前访问者相对应的链接对象，通常这是与访问者同类的对象，但是会经过接口进行抽象；而GetIdentical则可以获取与访问者同类链接的对象成员。 + +链路方向使用LinkType进行标记，也可以直接使用LinkType.SwapType()来快速反转这个链接标记； +LinkType可以直接和LinkedPortType相互进行转换，也可以使用LinkType.ConvertType()来快速转换类型。 +链路方向通常只用在内部作为方向标识，外部无法获取，一般只在设置时进行一次标识设置即可。 + + + +### 线路结构 +---- + +线路绘制组件提供了线路连接引用关系，可以将一个线连接到另一个线上，也可以用点将它们连接起来， +默认线 + + +### 生命周期 +---- + + +由于所有的成员都是通过批处理器完成生命周期的定义，批处理器的调用时机对于后续的流程来说至关重要。 +为了便于使用，所有的批处理对象的生命周期都遵循以下规则： + +``` +开始和结束时间在LateUpdate阶段触发； +主线程更新事件在Update阶段触发； +异步更新事件在LateUpdate阶段触发； + +主线程事件在所有事件之后才执行； +``` + +* 安全检查 +在批处理期间是允许销毁的，目前的安全限制仅限在更新前会检查一遍批处理的key值是否为空，在其他时刻，可以通过其他的接口传递的安全检查来辅助更新检查。 +比如在PromptLine2中，如果太早或太迟调用UpdateRender会导致在更新期间捕获到一个空引用的报错，来源是linerenderer组件在此时还不存在，具体原理不清楚，但是只会提示一次，所以此时的渲染操作可以直接跳过。 + +### 获取工具 +---- + + +如果希望获取放置物管理器中的工具： + +``` +// 获取当前激活的工具目标 +DecisionMakerToolBase.ActiveDecisionMaker +// 以及这个工具目标是否有效 +DecisionMakerToolBase.HasAciveDecisionMaker +``` + +### 示例文件 +---- + + +在Runtime/HorizonLineOrbit中已经提供了基本的用例，将SesothoPeManager挂到任意一个节点上就可以了。 +运行后按下键盘L键，此时点击世界中layer为defualt的物体，就会点击处y轴为0的位置上生成一个线，移动光标，线也会跟着移动。 + +这些脚本提供了一个基本的示例，并且几乎将所有可以进行配置修改的要素都呈现了出来，可以在后续的扩展中通过参考这些文件来进行实现。 + +在示例脚本中主要分为对元素的实现，以及对过程的实现； +* terminalPoint, TerminalLine2T3, TerminalIland是后续创建的实例所挂载的具有确定空间，绘制方式的实现。 +* 其他的都是管理器，工具，操作栈的实现。 + +其中管理器，工具，操作栈类都是层层嵌套的引用结构，尽量只让相邻的两个过程进行相互的引用，比如工具应该引用管理器的实现，开放给操作栈。 + + +### 使用须知 +---- + + +现在已知的线路绘制问题: +* 如果同时创建大量的操作栈(>500),并在之后的某个时刻中将它们全部隐式地释放掉,有可能会在之后的某个时刻带来庞大的GC占用(>90ms) +* 逆时针绘制的曲线线路没法计算最近点。 + +## XericLibrary + +XericLibrary 部分由两个dll组成，一个是 Xeric Library，另一个是 Xeric Library Editor 。 + +### 宏库 + +#### 特性库 +---- + +* CanFind$ + 其中包含多个特性类，用于查找类，字段，属性，方法等项目。 + +* ReName + 重命名特性，在没有安装odin插件的旧版本引擎上可以直接替换细节面板中的参数名称，不过由于无法和odin兼容，所以odin的功能会覆盖掉这个特性。 + 主要作用是提供属性标签查找功能。 + +#### 协程宏 +---- + +#### 调试宏 +---- + + + +#### 模型网格宏 +---- + + +#### 机器标识宏 +---- + + +#### 宏库 +---- +* 摄像机宏 +* 颜色宏 +* 常数宏 +* 曲线宏 +* 枚举宏 +* 方程宏 +* 事件宏 +* 文件宏 +* 步进宏 +* 按键宏 +* 集合宏 +* 数学宏 +* 对象宏 +* PID宏 +* 对象池宏 +* 矩形变换宏 +* 超驰宏 +* 仓库宏 +* 材质宏 +* 平滑宏 +* 排序宏 +* 文本宏 +* 时间宏 +* 轴变换宏 +* 类型扩展 +* 矢量扩展 + +#### 导航宏 +---- + +#### 安全宏 +---- + + +#### 转换宏 +---- + + +#### 独特类型 +---- + + + +### 简易批处理器 + +在代码中引用 XericLibrary.Runtime.Type.BatchProcess ， +并将需要进行批处理的对象实现 ICanBatchProcess 接口， +其中提供了所有额外支持的生命周期事件，可以直接实现或显式实现。 + +缺点是只有异步方法的生命周期约束，没有提供线程安全的数据类型。 + +和官方的相比没有什么优势，只是为了此处使用的方便。 + + +## DataBaseControl + +数据库控制器，当前主要工作区域是SqlClient部分 + +---- + +### 基础使用 + +数据库操作的指令被抽象到Order类了（我在注释里会称为解释器），比如sqlClient就是sqlcOrder，其中sqlc代表sqlclient。 +order类本质上是一个文本拼接器，为了方便管理，你可以使用对应类的order.GetOrder来获取池中的一条指令，比如： +``` +var orderValues = SQLCHelper.GetOrder(); +``` +这个orderValues必须手动释放才会回到池中，比如： +``` +orderValues.Dispost(); +``` +GetOrder指令可以在编译时静态调用，用作静态参数，不去释放，这样的话指令的生命周期会跟随程序释放而释放。 +使用指令前建议先清空，避免指令污染： +``` +orderValues.CleanOrder(); +``` +然后，可以在指令上调用对应的函数，里面预制了数据库连接增删改查，表增删改查，项增删改查，以及插入判断，筛选条件命令。 +对于连接功能，可以参考下面的示例： +``` +public void InitDataBase(string hostName, string databaseName, string tableName, + IEnumerable valueData) +{ + SQLCHelper.connectOrder.OrderSetServer(hostName, null); + // 数据库不存在，就创建一个 + if ((int)orderValues.OrderIsDataBaseExist(databaseName) + .ExecuteScalar() <= 0) + orderValues.OrderCreatDataBase(databaseName) + .ExecuteNonQuery(); + + SQLCHelper.connectOrder.OrderSetServer(hostName, databaseName); + // 数据表不存在，就创建一个 + if ((int)orderValues.OrderIsTableExist(tableName) + .ExecuteScalar() <= 0) + orderValues.OrderCreatTable(tableName) + .ExecuteNonQuery(); + + // 构建数据项目 + orderValues.CleanValue(); + orderValues.Values.AddRange(valueData.Select(a => new SqlCOrder.SqlCValue(a.name, a.value))); + + // 数据项目不存在，就创建一个 + if (valueData != null) + { + orderValues.OrderInsetTableItem(tableName); + } +} +``` +可以看到前面会使用同一个order指令来执行命令构建，然后通过Execute方法来执行指令。 +指令在构建时会将文本压入stringBuilder中，直到遇到Execute指令后，指令才会被拼接成具体的文本，存入历史指令中。 +当这个指令中stringBuilder里没有待输出的指令时，会优先使用之前拼接过的文本，也就是说一条已经构建的指令可以被重复执行。 + +刚刚的示例代码也可以通过调用预制的扩展方法完成，比如： +``` +orderValues.InitializationDataBase("localhost", "DEFAULT_DATABASE", "DEFAULT_TABLE"); +``` +上面这段指令会自动连接到地址localhost下，名为DEFAULT_DATABASE的DEFAULT_TABLE表中。 +如果数据库中没有库或表，将会自动创建。这对于仅仅为了保存数据的情况来说会比较方便。 +这种扩展指令根据其使用情景可能会相对于普通的方法有所区别，就比方说这个扩展方法会立刻执行，不需要手动调用Execute方法。 +一般指令都仅仅只是将命令填入拼接池中，然后在Execute中执行order里的SubmitOrder()来持久化指令内容。 + +如果希望在内存中保留一个与数据库对应的数值，则可以使用order的Values属性； +一个order里的Values对应一个数据库表里的一列下的一个数据。 +Value的name对应列名，value对应实际值。 + +还是上面那段完整的数据库创建函数实例中，最后的OrderInsetTableItem就是将values插入到表的指令，包括InitializationDataBase扩展中也会自动将当前执行的order里的values插入到表，所以这个指令会建议手动管理生命周期。 + +这里说明一下，指令里的方法名称是有特定规律的： +* 比如用于单段执行的指令方法，会使用Order开头，使用.Order...可以搜索到很多相关的指令。他们都会返回自身，用以支持链式的调用。 +* 如果某个指令的后面可以继续添加指令，比如条件指令之类的，可以使用.OrderJoin...搜索到一些相关的预制指令。 +* 而其他的指令则可以在扩展库中找到，扩展库中会专门针对特定的应用情景开放专门的方法。 + +#### 数据读写 + +在上面已经说过如何新建表，建表的时候会默认写入一次数据，而如果希望手动定义表格里的内容的话可以这么写： +``` +order.OrderJoinValuesDefinitinOnly(orderValues.Values); +``` +如果希望填入当前order里的Values的话，可以这么写： +``` +``` + +读取可以使用： +``` +orderValues.OrderSelect("DEFAULT_TABLE", null, null, true, true); +``` +这段指令将orderValues里的value作为项目进行查询，由于两个null没有指定条件和排序，所以这会返回所有value的值。 +记得使用ExecuteReader执行，并返回阅读器进行处理，在阅读器中，需要手动根据值名称一一对应地将值填回orderValues里。 + +不过在扩展类中也提供了自动地读取逻辑： +``` +orderValues.ReadLatestValue("DEFAULT_TABLE"); +``` +这会读取数据库中的，orderValues中的值，并直接写在orderValues的每一项中。 +然后直接对orderValues中的values进行处理姐可以了。 + +需要注意的是，这些指令虽然没有明确要求数据库连接，但还是至少需要连接过一次数据库，比如至少调用过一次InitializationDataBase方法，这样，后续的所有指令都可以不需要主动指定connectOrder项目。 + + diff --git a/README.md.meta b/README.md.meta new file mode 100644 index 0000000..fd6a290 --- /dev/null +++ b/README.md.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: 019144fe8aedc3f499e254bf3e42bf14 +TextScriptImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Resources/Material/Graph/Lit/SceneGround.mat b/Resources/Material/Graph/Lit/SceneGround.mat new file mode 100644 index 0000000..5490a7a --- /dev/null +++ b/Resources/Material/Graph/Lit/SceneGround.mat @@ -0,0 +1,117 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!21 &2100000 +Material: + serializedVersion: 8 + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_Name: SceneGround + m_Shader: {fileID: -6465566751694194690, guid: c508188bc2ab04746ba729aded8434fa, type: 3} + m_ValidKeywords: [] + m_InvalidKeywords: [] + m_LightmapFlags: 4 + m_EnableInstancingVariants: 0 + m_DoubleSidedGI: 0 + m_CustomRenderQueue: -1 + stringTagMap: {} + disabledShaderPasses: [] + m_SavedProperties: + serializedVersion: 3 + m_TexEnvs: + - _BumpMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _DetailAlbedoMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _DetailMask: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _DetailNormalMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _EmissionMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MainTex: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MetallicGlossMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _OcclusionMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _ParallaxMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _Texture2D: + m_Texture: {fileID: 10309, guid: 0000000000000000f000000000000000, type: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _Texture2D_Normal: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_Lightmaps: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_LightmapsInd: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_ShadowMasks: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + m_Ints: [] + m_Floats: + - _BUILTIN_QueueControl: 0 + - _BUILTIN_QueueOffset: 0 + - _BumpScale: 1 + - _Cutoff: 0.5 + - _DetailNormalMapScale: 1 + - _DstBlend: 0 + - _GlossMapScale: 1 + - _Glossiness: 0.5 + - _GlossyReflections: 1 + - _Metallic: 0 + - _Mode: 0 + - _OcclusionStrength: 1 + - _Parallax: 0.02 + - _QueueControl: -1 + - _QueueOffset: 0 + - _SmoothnessTextureChannel: 0 + - _SpecularHighlights: 1 + - _SrcBlend: 1 + - _UVSec: 0 + - _ZWrite: 1 + m_Colors: + - _Color: {r: 1, g: 1, b: 1, a: 1} + - _EmissionColor: {r: 0, g: 0, b: 0, a: 1} + m_BuildTextureStacks: [] +--- !u!114 &1580504613398626283 +MonoBehaviour: + m_ObjectHideFlags: 11 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 639247ca83abc874e893eb93af2b5e44, type: 3} + m_Name: + m_EditorClassIdentifier: + version: 0 diff --git a/Resources/Material/Graph/Lit/SceneGroundGraphs.shadergraph b/Resources/Material/Graph/Lit/SceneGroundGraphs.shadergraph new file mode 100644 index 0000000..36efe98 --- /dev/null +++ b/Resources/Material/Graph/Lit/SceneGroundGraphs.shadergraph @@ -0,0 +1,1212 @@ +{ + "m_SGVersion": 3, + "m_Type": "UnityEditor.ShaderGraph.GraphData", + "m_ObjectId": "275530f0cc8044cdb37c1eeab5b0d564", + "m_Properties": [ + { + "m_Id": "b17287c6b9294da7a8cb72f1b63be8ee" + }, + { + "m_Id": "a1bc40a084d94f7c80352c2a79ead977" + } + ], + "m_Keywords": [], + "m_Dropdowns": [], + "m_CategoryData": [ + { + "m_Id": "4ca15f54f4494d20904497259b8f2553" + } + ], + "m_Nodes": [ + { + "m_Id": "1a1080e6ddde4d5e9d51e7b643ceb557" + }, + { + "m_Id": "80e034e1e58a4385a0a407c721428dfe" + }, + { + "m_Id": "96dc238052ea4f039ae9750d683a6920" + }, + { + "m_Id": "ffc19a777b46441b8a94f59034e38b86" + }, + { + "m_Id": "1996420dbda54a099bd3683de1fcf67a" + }, + { + "m_Id": "34c07405c620440084d0213fd695bb37" + }, + { + "m_Id": "c6a8f8c0dbba4c1eb58d659f4a56da0b" + }, + { + "m_Id": "aa9649c99dfb4cdd82b3c7f5b9c8afd5" + }, + { + "m_Id": "789bfdd452f04d56bfba260ea1776279" + }, + { + "m_Id": "46518a3c852c4971bb44650753187c62" + }, + { + "m_Id": "090832bceb3a4f55ab8405d1f6cc1e3a" + }, + { + "m_Id": "85cf6092e34a40b98f89fec2d1019008" + }, + { + "m_Id": "18a68b11fe8449bfa4eae143c09b7630" + } + ], + "m_GroupDatas": [], + "m_StickyNoteDatas": [], + "m_Edges": [ + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "090832bceb3a4f55ab8405d1f6cc1e3a" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "46518a3c852c4971bb44650753187c62" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "46518a3c852c4971bb44650753187c62" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "ffc19a777b46441b8a94f59034e38b86" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "46518a3c852c4971bb44650753187c62" + }, + "m_SlotId": 7 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "18a68b11fe8449bfa4eae143c09b7630" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "85cf6092e34a40b98f89fec2d1019008" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "46518a3c852c4971bb44650753187c62" + }, + "m_SlotId": 2 + } + } + ], + "m_VertexContext": { + "m_Position": { + "x": 0.0, + "y": 0.0 + }, + "m_Blocks": [ + { + "m_Id": "1a1080e6ddde4d5e9d51e7b643ceb557" + }, + { + "m_Id": "80e034e1e58a4385a0a407c721428dfe" + }, + { + "m_Id": "96dc238052ea4f039ae9750d683a6920" + } + ] + }, + "m_FragmentContext": { + "m_Position": { + "x": 0.0, + "y": 200.0 + }, + "m_Blocks": [ + { + "m_Id": "ffc19a777b46441b8a94f59034e38b86" + }, + { + "m_Id": "1996420dbda54a099bd3683de1fcf67a" + }, + { + "m_Id": "34c07405c620440084d0213fd695bb37" + }, + { + "m_Id": "c6a8f8c0dbba4c1eb58d659f4a56da0b" + }, + { + "m_Id": "aa9649c99dfb4cdd82b3c7f5b9c8afd5" + }, + { + "m_Id": "789bfdd452f04d56bfba260ea1776279" + }, + { + "m_Id": "18a68b11fe8449bfa4eae143c09b7630" + } + ] + }, + "m_PreviewData": { + "serializedMesh": { + "m_SerializedMesh": "{\"mesh\":{\"fileID\":10210,\"guid\":\"0000000000000000e000000000000000\",\"type\":0}}", + "m_Guid": "" + }, + "preventRotation": true + }, + "m_Path": "Shader Graphs", + "m_GraphPrecision": 1, + "m_PreviewMode": 2, + "m_OutputNode": { + "m_Id": "" + }, + "m_ActiveTargets": [ + { + "m_Id": "ab3c67755ad04d0d864945b966c3b318" + } + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "090832bceb3a4f55ab8405d1f6cc1e3a", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1078.0, + "y": 166.00001525878907, + "width": 139.00006103515626, + "height": 33.999969482421878 + } + }, + "m_Slots": [ + { + "m_Id": "b44d30beb0f345b1affe4a1f04f67172" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "b17287c6b9294da7a8cb72f1b63be8ee" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "0fdc2a704db842bbbb746dd664494ac0", + "m_Id": 0, + "m_DisplayName": "Smoothness", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Smoothness", + "m_StageCapability": 2, + "m_Value": 0.5, + "m_DefaultValue": 0.5, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "18a68b11fe8449bfa4eae143c09b7630", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Alpha", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "3bf68d82074c449aaa7040faf76b3753" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Alpha" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "1996420dbda54a099bd3683de1fcf67a", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.NormalTS", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "b23e137b6f854076ac70211d22033dc8" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.NormalTS" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "1a1080e6ddde4d5e9d51e7b643ceb557", + "m_Group": { + "m_Id": "" + }, + "m_Name": "VertexDescription.Position", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "c85132e85f3a4b9697d9cc9cd44f7e79" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "VertexDescription.Position" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "1bbb216f11e04e15a410b34c2e2c37e4", + "m_Id": 1954524551, + "m_DisplayName": "OriginOffset", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "_OriginOffset", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ColorRGBMaterialSlot", + "m_ObjectId": "209dc336cfed4bff812989cc78465741", + "m_Id": 0, + "m_DisplayName": "Base Color", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "BaseColor", + "m_StageCapability": 2, + "m_Value": { + "x": 0.5, + "y": 0.5, + "z": 0.5 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_ColorMode": 0, + "m_DefaultColor": { + "r": 0.5, + "g": 0.5, + "b": 0.5, + "a": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "2b5a0bc9e33f424aaf79535460cb724f", + "m_Id": 0, + "m_DisplayName": "Ambient Occlusion", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Occlusion", + "m_StageCapability": 2, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "34c07405c620440084d0213fd695bb37", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Metallic", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "5a7cab2db494460187fb81b3aa7e865e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Metallic" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "3bf68d82074c449aaa7040faf76b3753", + "m_Id": 0, + "m_DisplayName": "Alpha", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Alpha", + "m_StageCapability": 2, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "3db78c311ece4e51bb7c44e50466f0b5", + "m_Id": 2, + "m_DisplayName": "index", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "index", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "46518a3c852c4971bb44650753187c62", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1078.0, + "y": 205.0, + "width": 183.0, + "height": 251.0 + } + }, + "m_Slots": [ + { + "m_Id": "9f2bffc2d2cf44379635bf0b63dbfe35" + }, + { + "m_Id": "4bb26fe8e87f403d8cd4c09acf519921" + }, + { + "m_Id": "801c0283490044c192355a9c8b520f8d" + }, + { + "m_Id": "77caf74be9444ef193f163f41ab47b43" + }, + { + "m_Id": "7a6fa7da827e41fea8250f6da57ab50a" + }, + { + "m_Id": "c282c259bddb4d1484b0272a2b4b6f39" + }, + { + "m_Id": "e84a3c21b81246e5b931b33d61af7f87" + }, + { + "m_Id": "7572fd07309b4598bb167457511f7232" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 0, + "m_NormalMapSpace": 0, + "m_EnableGlobalMipBias": true +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "4bb26fe8e87f403d8cd4c09acf519921", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.CategoryData", + "m_ObjectId": "4ca15f54f4494d20904497259b8f2553", + "m_Name": "", + "m_ChildObjectList": [ + { + "m_Id": "b17287c6b9294da7a8cb72f1b63be8ee" + }, + { + "m_Id": "a1bc40a084d94f7c80352c2a79ead977" + } + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "5a7cab2db494460187fb81b3aa7e865e", + "m_Id": 0, + "m_DisplayName": "Metallic", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Metallic", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2MaterialSlot", + "m_ObjectId": "6311704bd76643cda9b8c1b61e7ad7d8", + "m_Id": 1, + "m_DisplayName": "WorldUV", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "WorldUV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ColorRGBMaterialSlot", + "m_ObjectId": "635765667b94474fbcfb79c7d6f82204", + "m_Id": 0, + "m_DisplayName": "Emission", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Emission", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_ColorMode": 1, + "m_DefaultColor": { + "r": 0.0, + "g": 0.0, + "b": 0.0, + "a": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "7572fd07309b4598bb167457511f7232", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "77caf74be9444ef193f163f41ab47b43", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "789bfdd452f04d56bfba260ea1776279", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Occlusion", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "2b5a0bc9e33f424aaf79535460cb724f" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Occlusion" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "7a6fa7da827e41fea8250f6da57ab50a", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "801c0283490044c192355a9c8b520f8d", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "80e034e1e58a4385a0a407c721428dfe", + "m_Group": { + "m_Id": "" + }, + "m_Name": "VertexDescription.Normal", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "9a00ccd8ad364cca9561889cef8378ee" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "VertexDescription.Normal" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SubGraphNode", + "m_ObjectId": "85cf6092e34a40b98f89fec2d1019008", + "m_Group": { + "m_Id": "" + }, + "m_Name": "WorldUpVectorUV", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1291.0, + "y": 205.0, + "width": 213.0, + "height": 302.0000305175781 + } + }, + "m_Slots": [ + { + "m_Id": "88831a34875842bb80d0a474cb0e791d" + }, + { + "m_Id": "1bbb216f11e04e15a410b34c2e2c37e4" + }, + { + "m_Id": "6311704bd76643cda9b8c1b61e7ad7d8" + }, + { + "m_Id": "3db78c311ece4e51bb7c44e50466f0b5" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedSubGraph": "{\n \"subGraph\": {\n \"fileID\": -5475051401550479605,\n \"guid\": \"ea08eb5d0b2c0e3479804a22fa882c5c\",\n \"type\": 3\n }\n}", + "m_PropertyGuids": [ + "c07e0e91-06f9-441f-a0e7-a41baeadcbc4", + "b1ea27f6-c098-4ae0-8575-1d046c3f688b" + ], + "m_PropertyIds": [ + 1527661158, + 1954524551 + ], + "m_Dropdowns": [], + "m_DropdownSelectedEntries": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2MaterialSlot", + "m_ObjectId": "88831a34875842bb80d0a474cb0e791d", + "m_Id": 1527661158, + "m_DisplayName": "TileSize", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "_TileSize", + "m_StageCapability": 3, + "m_Value": { + "x": 2.0, + "y": 2.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.BuiltIn.ShaderGraph.BuiltInLitSubTarget", + "m_ObjectId": "88dba662e8674ebb95aea3681f836bd4", + "m_WorkflowMode": 1, + "m_NormalDropOffSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "96dc238052ea4f039ae9750d683a6920", + "m_Group": { + "m_Id": "" + }, + "m_Name": "VertexDescription.Tangent", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "9a6ca8bfea504202be0afe1b0a01f6a2" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "VertexDescription.Tangent" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.NormalMaterialSlot", + "m_ObjectId": "9a00ccd8ad364cca9561889cef8378ee", + "m_Id": 0, + "m_DisplayName": "Normal", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Normal", + "m_StageCapability": 1, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.TangentMaterialSlot", + "m_ObjectId": "9a6ca8bfea504202be0afe1b0a01f6a2", + "m_Id": 0, + "m_DisplayName": "Tangent", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Tangent", + "m_StageCapability": 1, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "9f2bffc2d2cf44379635bf0b63dbfe35", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "a1bc40a084d94f7c80352c2a79ead977", + "m_Guid": { + "m_GuidSerialized": "d5322d25-b786-4efa-b46d-bd8bef56a360" + }, + "m_Name": "Texture2D Normal", + "m_DefaultRefNameVersion": 1, + "m_RefNameGeneratedByDisplayName": "Texture2D Normal", + "m_DefaultReferenceName": "_Texture2D_Normal", + "m_OverrideReferenceName": "", + "m_GeneratePropertyBlock": true, + "m_UseCustomSlotLabel": false, + "m_CustomSlotLabel": "", + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "isMainTexture": false, + "useTilingAndOffset": false, + "m_Modifiable": true, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "aa9649c99dfb4cdd82b3c7f5b9c8afd5", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Emission", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "635765667b94474fbcfb79c7d6f82204" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Emission" +} + +{ + "m_SGVersion": 2, + "m_Type": "UnityEditor.Rendering.BuiltIn.ShaderGraph.BuiltInTarget", + "m_ObjectId": "ab3c67755ad04d0d864945b966c3b318", + "m_ActiveSubTarget": { + "m_Id": "88dba662e8674ebb95aea3681f836bd4" + }, + "m_AllowMaterialOverride": false, + "m_SurfaceType": 1, + "m_ZWriteControl": 0, + "m_ZTestMode": 4, + "m_AlphaMode": 0, + "m_RenderFace": 2, + "m_AlphaClip": false, + "m_CustomEditorGUI": "" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "b17287c6b9294da7a8cb72f1b63be8ee", + "m_Guid": { + "m_GuidSerialized": "dd8b3833-a421-4746-b71c-89cc2e37068b" + }, + "m_Name": "Texture2D", + "m_DefaultRefNameVersion": 1, + "m_RefNameGeneratedByDisplayName": "Texture2D", + "m_DefaultReferenceName": "_Texture2D", + "m_OverrideReferenceName": "", + "m_GeneratePropertyBlock": true, + "m_UseCustomSlotLabel": false, + "m_CustomSlotLabel": "", + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "isMainTexture": false, + "useTilingAndOffset": false, + "m_Modifiable": true, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.NormalMaterialSlot", + "m_ObjectId": "b23e137b6f854076ac70211d22033dc8", + "m_Id": 0, + "m_DisplayName": "Normal (Tangent Space)", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "NormalTS", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 3 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "b44d30beb0f345b1affe4a1f04f67172", + "m_Id": 0, + "m_DisplayName": "Texture2D", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "c282c259bddb4d1484b0272a2b4b6f39", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "c6a8f8c0dbba4c1eb58d659f4a56da0b", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Smoothness", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "0fdc2a704db842bbbb746dd664494ac0" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Smoothness" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PositionMaterialSlot", + "m_ObjectId": "c85132e85f3a4b9697d9cc9cd44f7e79", + "m_Id": 0, + "m_DisplayName": "Position", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Position", + "m_StageCapability": 1, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "e84a3c21b81246e5b931b33d61af7f87", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "ffc19a777b46441b8a94f59034e38b86", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.BaseColor", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "209dc336cfed4bff812989cc78465741" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.BaseColor" +} + diff --git a/Resources/Material/Graph/UI/UISelectionBoxDraw.mat b/Resources/Material/Graph/UI/UISelectionBoxDraw.mat new file mode 100644 index 0000000..d0a085a --- /dev/null +++ b/Resources/Material/Graph/UI/UISelectionBoxDraw.mat @@ -0,0 +1,157 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!21 &2100000 +Material: + serializedVersion: 8 + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_Name: UISelectionBoxDraw + m_Shader: {fileID: 10753, guid: 0000000000000000f000000000000000, type: 0} + m_ValidKeywords: [] + m_InvalidKeywords: + - _BUILTIN_SURFACE_TYPE_TRANSPARENT + m_LightmapFlags: 4 + m_EnableInstancingVariants: 0 + m_DoubleSidedGI: 0 + m_CustomRenderQueue: -1 + stringTagMap: {} + disabledShaderPasses: [] + m_SavedProperties: + serializedVersion: 3 + m_TexEnvs: + - _AlphaTex: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _BumpMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _DetailAlbedoMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _DetailMask: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _DetailNormalMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _EmissionMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MainTex: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MetallicGlossMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _OcclusionMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _ParallaxMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_Lightmaps: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_LightmapsInd: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_ShadowMasks: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + m_Ints: [] + m_Floats: + - PixelSnap: 0 + - _Alpha: 0.2 + - _BUILTIN_AlphaClip: 0 + - _BUILTIN_Blend: 0 + - _BUILTIN_CullMode: 2 + - _BUILTIN_DstBlend: 10 + - _BUILTIN_QueueControl: 0 + - _BUILTIN_QueueOffset: 0 + - _BUILTIN_SrcBlend: 5 + - _BUILTIN_Surface: 1 + - _BUILTIN_ZTest: 4 + - _BUILTIN_ZWrite: 0 + - _BUILTIN_ZWriteControl: 0 + - _BumpScale: 1 + - _ColorMask: 15 + - _CullMode: 0 + - _Cutoff: 0.5 + - _DetailNormalMapScale: 1 + - _DstBlend: 0 + - _Edge: 5 + - _EdgeAlpha: 0.8 + - _EdgeThera: 0.0001 + - _EnableExternalAlpha: 0 + - _GlossMapScale: 1 + - _Glossiness: 0.5 + - _GlossyReflections: 1 + - _Metallic: 0 + - _Mode: 0 + - _OcclusionStrength: 1 + - _Parallax: 0.02 + - _Precision: 100 + - _QueueControl: -1 + - _QueueOffset: 0 + - _SmoothnessTextureChannel: 0 + - _SpecularHighlights: 1 + - _SrcBlend: 1 + - _Stencil: 0 + - _StencilComp: 8 + - _StencilOp: 0 + - _StencilReadMask: 255 + - _StencilWriteMask: 255 + - _UVSec: 0 + - _UseUIAlphaClip: 0 + - _ZWrite: 1 + m_Colors: + - _ClipRect: {r: -32767, g: -32767, b: 32767, a: 32767} + - _Color: {r: 1, g: 1, b: 1, a: 1} + - _EdgeColor: {r: 1, g: 1, b: 1, a: 0.8352941} + - _EmissionColor: {r: 0, g: 0, b: 0, a: 1} + - _Flip: {r: 1, g: 1, b: 1, a: 1} + - _Point1: {r: 0, g: 0, b: 0, a: 0} + - _Point2: {r: 0, g: 0, b: 0, a: 0} + - _RendererColor: {r: 1, g: 1, b: 1, a: 1} + m_BuildTextureStacks: [] +--- !u!114 &5744030932169462819 +MonoBehaviour: + m_ObjectHideFlags: 11 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 639247ca83abc874e893eb93af2b5e44, type: 3} + m_Name: + m_EditorClassIdentifier: + version: 0 +--- !u!114 &7813913351238974909 +MonoBehaviour: + m_ObjectHideFlags: 11 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3} + m_Name: + m_EditorClassIdentifier: + version: 5 diff --git a/Resources/Material/Graph/UI/UISelectionBoxGraphs.shadergraph b/Resources/Material/Graph/UI/UISelectionBoxGraphs.shadergraph new file mode 100644 index 0000000..54366cc --- /dev/null +++ b/Resources/Material/Graph/UI/UISelectionBoxGraphs.shadergraph @@ -0,0 +1,8176 @@ +{ + "m_SGVersion": 3, + "m_Type": "UnityEditor.ShaderGraph.GraphData", + "m_ObjectId": "1bc02e2f9b4b40c8b55af4561e7902b7", + "m_Properties": [ + { + "m_Id": "9d7ee9e86af1446d8ab1ec1c058ecfee" + }, + { + "m_Id": "e32cc799c0204e05ba1d30c02e3eb720" + }, + { + "m_Id": "44a3b27e93754e2ca9445c452d735073" + }, + { + "m_Id": "0037bf0f4de94a8d885c1c6dac42056c" + }, + { + "m_Id": "6dd2b1faba004a728ed5d208c9efa1c1" + }, + { + "m_Id": "9a1da2cbbb434c87b01edd10819c1b63" + } + ], + "m_Keywords": [], + "m_Dropdowns": [], + "m_CategoryData": [ + { + "m_Id": "42ad688ddbab42de8a1f6f00b88a2318" + } + ], + "m_Nodes": [ + { + "m_Id": "618233005983415c89e0a7289c836914" + }, + { + "m_Id": "6f560bcaaa3e452fa440a497ef419724" + }, + { + "m_Id": "02caf17e1f1c4307aefa37a0642b63de" + }, + { + "m_Id": "7bb2d3223a634f5fbbfc8fb2efcc138c" + }, + { + "m_Id": "57f28b2075c848ac871156ba6051feaa" + }, + { + "m_Id": "babd9bfbe8dd4dc494543a2ee21b38e6" + }, + { + "m_Id": "11a2e56b46f0475eae04384853ac3d37" + }, + { + "m_Id": "09e0d6f042b74846bd07381d5a1cc77b" + }, + { + "m_Id": "4d66744c089e482db328fcc1135ba68a" + }, + { + "m_Id": "931fa242670f465c8e345681f62d4706" + }, + { + "m_Id": "5a5aa7a85fb94e27b4b8d393823e3a3a" + }, + { + "m_Id": "8402c7792aeb4b08b975b4b47d096545" + }, + { + "m_Id": "6466c63d9353433e889ec7eada999295" + }, + { + "m_Id": "3c098bb61d004ea79d54468b1473841c" + }, + { + "m_Id": "5d87e27df271488f8d357c61ffad3f91" + }, + { + "m_Id": "812df07afd8d4f929191cee9cc64e09f" + }, + { + "m_Id": "1cc18fed272e4131ac199eb6279a8083" + }, + { + "m_Id": "a9c305554f2648c3b0cf10d8e5f0f241" + }, + { + "m_Id": "39a1e33549914950aa134a324354cfcd" + }, + { + "m_Id": "78fccb4c15e94754949e901b97d47fab" + }, + { + "m_Id": "9026c55427fc43fe8fbee3890dff1724" + }, + { + "m_Id": "9315d54910e0411d8e3d940c21d2bd41" + }, + { + "m_Id": "c2da02f30d58454a839b8ea2ab088a9e" + }, + { + "m_Id": "1bb87653816448cbad25d83caf84d4bf" + }, + { + "m_Id": "61859cf0e65a47d4b0dfab22edd0bf9d" + }, + { + "m_Id": "1e5fab3f08ad48e2b575c37f2ee526ec" + }, + { + "m_Id": "05f1cee40a2f40f9987048a66e8c6583" + }, + { + "m_Id": "78d08c62c8294005bdf49a28d34014dc" + }, + { + "m_Id": "e43d15309eee469899e39c52487f5717" + }, + { + "m_Id": "63e7eb32cb2e4105829dbbb24ee90eab" + }, + { + "m_Id": "5e8e5336ed634a0fbc5860d58df29c09" + }, + { + "m_Id": "b0ffcfa3615f451abf62e7f6b171170d" + }, + { + "m_Id": "5cdb08742bac484599862b68c1d1284d" + }, + { + "m_Id": "5aded1b2bbdf4ca2b7a5ef92b985adcb" + }, + { + "m_Id": "a7d7e10a1b994d50a5318b247bde6e99" + }, + { + "m_Id": "54407f56f36c4fd49af88d89edf8696a" + }, + { + "m_Id": "9c9b01c30c284447b28c23ee375bb23f" + }, + { + "m_Id": "98f0cba8df5a47c68bbc07fc292dc06a" + }, + { + "m_Id": "db6a09bd547142099e2279980c5b54d0" + }, + { + "m_Id": "ac4cfe70546d4159a58e1cce895bb482" + }, + { + "m_Id": "965b3bc1c6bc44039b9d51567ce75df5" + }, + { + "m_Id": "cfae2a2a50f34b649ce8e7e43e4784e4" + }, + { + "m_Id": "070c05527b0b48c4baba360d824a2b4b" + }, + { + "m_Id": "7d511e39661947a28a6f833ba03cd339" + }, + { + "m_Id": "5a3a6d335b24450ab68ca68224bd8040" + }, + { + "m_Id": "b6d5b9e00f1040c0b71de21ad2ee1273" + }, + { + "m_Id": "7e173870f2064f2fb02be49bf4fe72e7" + }, + { + "m_Id": "57924e6529754609923b1a5f2933cc3a" + }, + { + "m_Id": "6f7bbb3dff13474b974352b7eb99af93" + }, + { + "m_Id": "964c7f01f6774420ad4d54b78197a264" + }, + { + "m_Id": "c4d83597b77a47e0ba14a5dbf5460278" + }, + { + "m_Id": "fd32acfe2a3040f9b19074bb36a417e4" + }, + { + "m_Id": "49f4e2d3805240ed9d55247c1be6eeaa" + }, + { + "m_Id": "0bf0a73ccec44377ab675a4289d2ab0f" + }, + { + "m_Id": "d541d33009844984a3a929cb08909fb3" + }, + { + "m_Id": "9edd1fd03d1741c2bde179115e6b5370" + }, + { + "m_Id": "277d35f6fbdb4e05b6eaf95b81552d0d" + }, + { + "m_Id": "d199153182574e7186e7cd7aaf23e9b3" + }, + { + "m_Id": "f897f715292a45a391d817a048261657" + }, + { + "m_Id": "16248bb017444af3bcd989c3fce179af" + } + ], + "m_GroupDatas": [], + "m_StickyNoteDatas": [], + "m_Edges": [ + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "05f1cee40a2f40f9987048a66e8c6583" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "ac4cfe70546d4159a58e1cce895bb482" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "05f1cee40a2f40f9987048a66e8c6583" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "ac4cfe70546d4159a58e1cce895bb482" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "070c05527b0b48c4baba360d824a2b4b" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "78d08c62c8294005bdf49a28d34014dc" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "09e0d6f042b74846bd07381d5a1cc77b" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "4d66744c089e482db328fcc1135ba68a" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "09e0d6f042b74846bd07381d5a1cc77b" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "5a5aa7a85fb94e27b4b8d393823e3a3a" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "09e0d6f042b74846bd07381d5a1cc77b" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "8402c7792aeb4b08b975b4b47d096545" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "09e0d6f042b74846bd07381d5a1cc77b" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "931fa242670f465c8e345681f62d4706" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "0bf0a73ccec44377ab675a4289d2ab0f" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "d541d33009844984a3a929cb08909fb3" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "11a2e56b46f0475eae04384853ac3d37" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "4d66744c089e482db328fcc1135ba68a" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "11a2e56b46f0475eae04384853ac3d37" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "5a5aa7a85fb94e27b4b8d393823e3a3a" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "11a2e56b46f0475eae04384853ac3d37" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "8402c7792aeb4b08b975b4b47d096545" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "11a2e56b46f0475eae04384853ac3d37" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "931fa242670f465c8e345681f62d4706" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "16248bb017444af3bcd989c3fce179af" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "54407f56f36c4fd49af88d89edf8696a" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "1bb87653816448cbad25d83caf84d4bf" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "61859cf0e65a47d4b0dfab22edd0bf9d" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "1cc18fed272e4131ac199eb6279a8083" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "a9c305554f2648c3b0cf10d8e5f0f241" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "1e5fab3f08ad48e2b575c37f2ee526ec" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "05f1cee40a2f40f9987048a66e8c6583" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "277d35f6fbdb4e05b6eaf95b81552d0d" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "9edd1fd03d1741c2bde179115e6b5370" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "39a1e33549914950aa134a324354cfcd" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "61859cf0e65a47d4b0dfab22edd0bf9d" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "3c098bb61d004ea79d54468b1473841c" + }, + "m_SlotId": 6 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "5d87e27df271488f8d357c61ffad3f91" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "3c098bb61d004ea79d54468b1473841c" + }, + "m_SlotId": 6 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "812df07afd8d4f929191cee9cc64e09f" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "3c098bb61d004ea79d54468b1473841c" + }, + "m_SlotId": 6 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "9026c55427fc43fe8fbee3890dff1724" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "3c098bb61d004ea79d54468b1473841c" + }, + "m_SlotId": 6 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "d199153182574e7186e7cd7aaf23e9b3" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "4d66744c089e482db328fcc1135ba68a" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6466c63d9353433e889ec7eada999295" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "54407f56f36c4fd49af88d89edf8696a" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "f897f715292a45a391d817a048261657" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "57924e6529754609923b1a5f2933cc3a" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "7e173870f2064f2fb02be49bf4fe72e7" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "57924e6529754609923b1a5f2933cc3a" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "9c9b01c30c284447b28c23ee375bb23f" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "57f28b2075c848ac871156ba6051feaa" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "11a2e56b46f0475eae04384853ac3d37" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "5a3a6d335b24450ab68ca68224bd8040" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "b6d5b9e00f1040c0b71de21ad2ee1273" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "5a5aa7a85fb94e27b4b8d393823e3a3a" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "3c098bb61d004ea79d54468b1473841c" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "5aded1b2bbdf4ca2b7a5ef92b985adcb" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "a7d7e10a1b994d50a5318b247bde6e99" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "5aded1b2bbdf4ca2b7a5ef92b985adcb" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "a7d7e10a1b994d50a5318b247bde6e99" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "5d87e27df271488f8d357c61ffad3f91" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "1cc18fed272e4131ac199eb6279a8083" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "5d87e27df271488f8d357c61ffad3f91" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "812df07afd8d4f929191cee9cc64e09f" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "5e8e5336ed634a0fbc5860d58df29c09" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "b0ffcfa3615f451abf62e7f6b171170d" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "61859cf0e65a47d4b0dfab22edd0bf9d" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "1e5fab3f08ad48e2b575c37f2ee526ec" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "61859cf0e65a47d4b0dfab22edd0bf9d" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "7d511e39661947a28a6f833ba03cd339" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "6466c63d9353433e889ec7eada999295" + }, + "m_SlotId": 6 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "1cc18fed272e4131ac199eb6279a8083" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "6466c63d9353433e889ec7eada999295" + }, + "m_SlotId": 6 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "5d87e27df271488f8d357c61ffad3f91" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "6466c63d9353433e889ec7eada999295" + }, + "m_SlotId": 6 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "78fccb4c15e94754949e901b97d47fab" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "6466c63d9353433e889ec7eada999295" + }, + "m_SlotId": 6 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "d199153182574e7186e7cd7aaf23e9b3" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "6f7bbb3dff13474b974352b7eb99af93" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "98f0cba8df5a47c68bbc07fc292dc06a" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "78fccb4c15e94754949e901b97d47fab" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "c2da02f30d58454a839b8ea2ab088a9e" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "7d511e39661947a28a6f833ba03cd339" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "5a3a6d335b24450ab68ca68224bd8040" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "7e173870f2064f2fb02be49bf4fe72e7" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6f7bbb3dff13474b974352b7eb99af93" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "812df07afd8d4f929191cee9cc64e09f" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "a9c305554f2648c3b0cf10d8e5f0f241" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "8402c7792aeb4b08b975b4b47d096545" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "3c098bb61d004ea79d54468b1473841c" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "9026c55427fc43fe8fbee3890dff1724" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "c2da02f30d58454a839b8ea2ab088a9e" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "9315d54910e0411d8e3d940c21d2bd41" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "78fccb4c15e94754949e901b97d47fab" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "9315d54910e0411d8e3d940c21d2bd41" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "9026c55427fc43fe8fbee3890dff1724" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "931fa242670f465c8e345681f62d4706" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6466c63d9353433e889ec7eada999295" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "964c7f01f6774420ad4d54b78197a264" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "070c05527b0b48c4baba360d824a2b4b" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "965b3bc1c6bc44039b9d51567ce75df5" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "070c05527b0b48c4baba360d824a2b4b" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "98f0cba8df5a47c68bbc07fc292dc06a" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "49f4e2d3805240ed9d55247c1be6eeaa" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "98f0cba8df5a47c68bbc07fc292dc06a" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "cfae2a2a50f34b649ce8e7e43e4784e4" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "9c9b01c30c284447b28c23ee375bb23f" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6f7bbb3dff13474b974352b7eb99af93" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "9edd1fd03d1741c2bde179115e6b5370" + }, + "m_SlotId": 4 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "965b3bc1c6bc44039b9d51567ce75df5" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "a7d7e10a1b994d50a5318b247bde6e99" + }, + "m_SlotId": 6 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "16248bb017444af3bcd989c3fce179af" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "a9c305554f2648c3b0cf10d8e5f0f241" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "39a1e33549914950aa134a324354cfcd" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "ac4cfe70546d4159a58e1cce895bb482" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "e43d15309eee469899e39c52487f5717" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "b6d5b9e00f1040c0b71de21ad2ee1273" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "9c9b01c30c284447b28c23ee375bb23f" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "b6d5b9e00f1040c0b71de21ad2ee1273" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "7e173870f2064f2fb02be49bf4fe72e7" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "babd9bfbe8dd4dc494543a2ee21b38e6" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "09e0d6f042b74846bd07381d5a1cc77b" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "c2da02f30d58454a839b8ea2ab088a9e" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "1bb87653816448cbad25d83caf84d4bf" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "c4d83597b77a47e0ba14a5dbf5460278" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "49f4e2d3805240ed9d55247c1be6eeaa" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "cfae2a2a50f34b649ce8e7e43e4784e4" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "964c7f01f6774420ad4d54b78197a264" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "d199153182574e7186e7cd7aaf23e9b3" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "16248bb017444af3bcd989c3fce179af" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "d541d33009844984a3a929cb08909fb3" + }, + "m_SlotId": 4 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "964c7f01f6774420ad4d54b78197a264" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "db6a09bd547142099e2279980c5b54d0" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "f897f715292a45a391d817a048261657" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "e43d15309eee469899e39c52487f5717" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "7d511e39661947a28a6f833ba03cd339" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "e43d15309eee469899e39c52487f5717" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "965b3bc1c6bc44039b9d51567ce75df5" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "e43d15309eee469899e39c52487f5717" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "cfae2a2a50f34b649ce8e7e43e4784e4" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "f897f715292a45a391d817a048261657" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "5a3a6d335b24450ab68ca68224bd8040" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "fd32acfe2a3040f9b19074bb36a417e4" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "49f4e2d3805240ed9d55247c1be6eeaa" + }, + "m_SlotId": 1 + } + } + ], + "m_VertexContext": { + "m_Position": { + "x": 1679.9998779296875, + "y": -571.9999389648438 + }, + "m_Blocks": [ + { + "m_Id": "618233005983415c89e0a7289c836914" + }, + { + "m_Id": "6f560bcaaa3e452fa440a497ef419724" + }, + { + "m_Id": "02caf17e1f1c4307aefa37a0642b63de" + }, + { + "m_Id": "63e7eb32cb2e4105829dbbb24ee90eab" + } + ] + }, + "m_FragmentContext": { + "m_Position": { + "x": 1722.0, + "y": 110.99993896484375 + }, + "m_Blocks": [ + { + "m_Id": "7bb2d3223a634f5fbbfc8fb2efcc138c" + }, + { + "m_Id": "78d08c62c8294005bdf49a28d34014dc" + } + ] + }, + "m_PreviewData": { + "serializedMesh": { + "m_SerializedMesh": "{\"mesh\":{\"fileID\":10210,\"guid\":\"0000000000000000e000000000000000\",\"type\":0}}", + "m_Guid": "" + }, + "preventRotation": true + }, + "m_Path": "Shader Graphs", + "m_GraphPrecision": 0, + "m_PreviewMode": 2, + "m_OutputNode": { + "m_Id": "" + }, + "m_ActiveTargets": [ + { + "m_Id": "725b3c9a4d7449479dbc9a999017251f" + } + ] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "0037bf0f4de94a8d885c1c6dac42056c", + "m_Guid": { + "m_GuidSerialized": "4716b020-c31a-46e8-82a1-b68ecb1cb3e5" + }, + "m_Name": "EdgeThera", + "m_DefaultRefNameVersion": 1, + "m_RefNameGeneratedByDisplayName": "EdgeThera", + "m_DefaultReferenceName": "_EdgeThera", + "m_OverrideReferenceName": "", + "m_GeneratePropertyBlock": true, + "m_UseCustomSlotLabel": false, + "m_CustomSlotLabel": "", + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.0, + "m_FloatType": 0, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "013d6bbb0c83407c80f8f5a45e3a203e", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "024ed61ec15142d8819ef6df6a771029", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "02caf17e1f1c4307aefa37a0642b63de", + "m_Group": { + "m_Id": "" + }, + "m_Name": "VertexDescription.Tangent", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "80dc8008598148718b8e868793a241b0" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "VertexDescription.Tangent" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "0335ac23fdb2409f9b3d31b9d5647796", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SplitNode", + "m_ObjectId": "05f1cee40a2f40f9987048a66e8c6583", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Split", + "m_DrawState": { + "m_Expanded": false, + "m_Position": { + "serializedVersion": "2", + "x": -406.0001220703125, + "y": 202.99998474121095, + "width": 119.00003051757813, + "height": 100.99998474121094 + } + }, + "m_Slots": [ + { + "m_Id": "becac710070447b9998c640490b19c95" + }, + { + "m_Id": "bd7b025dc417461088d2c1f8b88f67fc" + }, + { + "m_Id": "2da72e7616c54b89b54a20f3c38eaf27" + }, + { + "m_Id": "22e2b4317bf44fd68e57a0234552d0f7" + }, + { + "m_Id": "607bde7fe5e84817b6dbf7995d5f2ff8" + } + ], + "synonyms": [ + "separate" + ], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MaximumNode", + "m_ObjectId": "070c05527b0b48c4baba360d824a2b4b", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Maximum", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 1226.0001220703125, + "y": 500.9999084472656, + "width": 125.9998779296875, + "height": 118.00009155273438 + } + }, + "m_Slots": [ + { + "m_Id": "6adcfebd8ae840438050c77478fe437c" + }, + { + "m_Id": "ac092cd90d8b4f368b5865e2e2ea91a6" + }, + { + "m_Id": "22823ab565414735997dd3e08e64a83e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "085efa9bb1df48b0ac252017d6ccc0ca", + "m_Id": 1, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "091d7a4e859241a6a27745eb514e5fcc", + "m_Id": 4, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "0930a46e9ec7475d9448b7d922d23ad1", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SplitNode", + "m_ObjectId": "09e0d6f042b74846bd07381d5a1cc77b", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Split", + "m_DrawState": { + "m_Expanded": false, + "m_Position": { + "serializedVersion": "2", + "x": -2222.000244140625, + "y": 466.00006103515627, + "width": 119.0, + "height": 99.99993896484375 + } + }, + "m_Slots": [ + { + "m_Id": "26cb3a1da80940408faa605033397ee7" + }, + { + "m_Id": "6c2a8ac87cf94cd5bb9e33af357d876c" + }, + { + "m_Id": "f69fada9ab80444e8f3160b51e732613" + }, + { + "m_Id": "a0e85c82db424faba0dbbf2452e9b4c2" + }, + { + "m_Id": "663fe1a6f70a42c396b41abd6e928b92" + } + ], + "synonyms": [ + "separate" + ], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "0a313b7dc94042c6999a4f6af9f25848", + "m_Id": 0, + "m_DisplayName": "Edge", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "0bf0a73ccec44377ab675a4289d2ab0f", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 1100.0, + "y": 272.0, + "width": 132.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "352ba0f335544e35b07a6f7df3360f5c" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "9a1da2cbbb434c87b01edd10819c1b63" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "0fb700d77039488d98f6cbe2470503e4", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "0fc25573d0fc4629ac8d69f5bb434200", + "m_Id": 0, + "m_DisplayName": "Color", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "0ffc67215ae84d64803fafe4adde6320", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SplitNode", + "m_ObjectId": "11a2e56b46f0475eae04384853ac3d37", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Split", + "m_DrawState": { + "m_Expanded": false, + "m_Position": { + "serializedVersion": "2", + "x": -2222.000244140625, + "y": 111.99998474121094, + "width": 119.0, + "height": 101.0 + } + }, + "m_Slots": [ + { + "m_Id": "ee6cf9ccc94545e3890adefbba78c0d9" + }, + { + "m_Id": "699e9d5b0855487f8f13942f237b0e61" + }, + { + "m_Id": "cf75c9643f7a44bd83d6285125195f2a" + }, + { + "m_Id": "7147f9108cef4330a9324469ba504e65" + }, + { + "m_Id": "7b4994927f9d436ba8214b9ab82c908d" + } + ], + "synonyms": [ + "separate" + ], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "13583df735e04ca19cdf710a83a1652b", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "1596081c467247fca91f29b4046c3d38", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "16248bb017444af3bcd989c3fce179af", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1332.0, + "y": 584.0, + "width": 130.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "f1ad687730c84a98aec04547082f7b72" + }, + { + "m_Id": "ef090b7af48f406f97b34882f60fe768" + }, + { + "m_Id": "2c8e49f7abe948a69b0f613024659a38" + } + ], + "synonyms": [ + "multiplication", + "times", + "x" + ], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "1ae51bb4ac7f4510bcde3b70e23d8548", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "1bb87653816448cbad25d83caf84d4bf", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": false, + "m_Position": { + "serializedVersion": "2", + "x": -796.0, + "y": 111.99999237060547, + "width": 129.99993896484376, + "height": 94.0000228881836 + } + }, + "m_Slots": [ + { + "m_Id": "571e34592f8b4f92969b1b92ff090607" + }, + { + "m_Id": "3d43b0b264134762a99a9b18aa614cb5" + }, + { + "m_Id": "bfa2dc825b7f4bd7bb3076e3c83cb90a" + } + ], + "synonyms": [ + "multiplication", + "times", + "x" + ], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "1bc4750e64b34fd493653746316c400c", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SubtractNode", + "m_ObjectId": "1cc18fed272e4131ac199eb6279a8083", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Subtract", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1462.0001220703125, + "y": 171.00001525878907, + "width": 130.0, + "height": 117.99998474121094 + } + }, + "m_Slots": [ + { + "m_Id": "0335ac23fdb2409f9b3d31b9d5647796" + }, + { + "m_Id": "4a1287facb184577900a12f9bef16aa7" + }, + { + "m_Id": "bf1d4b549e0b48ae9133c646a125b639" + } + ], + "synonyms": [ + "subtraction", + "remove", + "minus", + "take away" + ], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "1ced1b90f5574558b6fee8dce23c553a", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "1d6cca8f50814d7a88571cf30e0bdd46", + "m_Id": 4, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "1e39188f9e1649628293001eb99291ba", + "m_Id": 4, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MaximumNode", + "m_ObjectId": "1e5fab3f08ad48e2b575c37f2ee526ec", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Maximum", + "m_DrawState": { + "m_Expanded": false, + "m_Position": { + "serializedVersion": "2", + "x": -536.0001220703125, + "y": 202.99998474121095, + "width": 130.0, + "height": 94.00007629394531 + } + }, + "m_Slots": [ + { + "m_Id": "fdcbfa10eba048faad43b3da6d7225e3" + }, + { + "m_Id": "b21d4ff4c92f4513bb21347382e47019" + }, + { + "m_Id": "706e6419f3544c8cbe6b4513577fab71" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2MaterialSlot", + "m_ObjectId": "1fd369b37c9b40ef9cda54ae5de2d7fe", + "m_Id": 0, + "m_DisplayName": "Point1", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "1fdc892bb55545a2b4a442938eced5a4", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "2058b054ebdc4420b214562023ee8749", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "20944635d9f1412dab104114e6a81d1b", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "22823ab565414735997dd3e08e64a83e", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "22e2b4317bf44fd68e57a0234552d0f7", + "m_Id": 3, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "247503c695d746e6a2da88e9c22ed35b", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "26cb3a1da80940408faa605033397ee7", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "277d35f6fbdb4e05b6eaf95b81552d0d", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 848.0000610351563, + "y": 382.9999694824219, + "width": 105.0, + "height": 34.000030517578128 + } + }, + "m_Slots": [ + { + "m_Id": "a326ea6261b74ad2bc375d566c42ce90" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "6dd2b1faba004a728ed5d208c9efa1c1" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "29142e3939a441868f6f5246e839d5d9", + "m_Id": 1, + "m_DisplayName": "G", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 3, + "m_Value": 640.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "29eff7490f964eb7911f0e9c4bd1b87b", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "2c8e49f7abe948a69b0f613024659a38", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "2d783bd53df94c1ca5ff994a0ab1a429", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "2da72e7616c54b89b54a20f3c38eaf27", + "m_Id": 2, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "2de3477aae07402a99be998a67ce2ee6", + "m_Id": 0, + "m_DisplayName": "Alpha", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Alpha", + "m_StageCapability": 2, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "30055067eee74a2f818c87cff2ad86a9", + "m_Id": 5, + "m_DisplayName": "RGB", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGB", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "304bcc3b99004c89b9d2b3b7262b3169", + "m_Id": 5, + "m_DisplayName": "RGB", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGB", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "3277987125264aa58a18f8e58e429d05", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PositionMaterialSlot", + "m_ObjectId": "35024b2926e048ebbc15c9842f0172b2", + "m_Id": 0, + "m_DisplayName": "Position", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Position", + "m_StageCapability": 1, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "352ba0f335544e35b07a6f7df3360f5c", + "m_Id": 0, + "m_DisplayName": "EdgeColor", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.AbsoluteNode", + "m_ObjectId": "39a1e33549914950aa134a324354cfcd", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Absolute", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1202.0001220703125, + "y": 230.00001525878907, + "width": 131.0, + "height": 93.99998474121094 + } + }, + "m_Slots": [ + { + "m_Id": "5f4cc034ff7940319ce494ff56fce947" + }, + { + "m_Id": "7e0efaf8f4a6489b81827f44fbb9bf1e" + } + ], + "synonyms": [ + "positive" + ], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.CombineNode", + "m_ObjectId": "3c098bb61d004ea79d54468b1473841c", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Combine", + "m_DrawState": { + "m_Expanded": false, + "m_Position": { + "serializedVersion": "2", + "x": -1717.0001220703125, + "y": 348.00006103515627, + "width": 140.0, + "height": 165.99993896484376 + } + }, + "m_Slots": [ + { + "m_Id": "e0896f5d9442475596126b72d32015dc" + }, + { + "m_Id": "c5f46bf6e45c4fbbb0bfcc3c2b9cdeef" + }, + { + "m_Id": "63d81c5c394445f5b488f1cb60910840" + }, + { + "m_Id": "67891136c56545138b979b8816d55b40" + }, + { + "m_Id": "091d7a4e859241a6a27745eb514e5fcc" + }, + { + "m_Id": "30055067eee74a2f818c87cff2ad86a9" + }, + { + "m_Id": "efa6dbf958c043078d6fb1e41d1092bf" + } + ], + "synonyms": [ + "append" + ], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "3c52bece8d464ac59e255f0eb73927c9", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "3d43b0b264134762a99a9b18aa614cb5", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": -1.0, + "e01": -1.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "3fedfbc45fe04019b5101759e9bc10cc", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "422a1a3ab9204aafbfb3ffc28e589967", + "m_Id": 3, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.CategoryData", + "m_ObjectId": "42ad688ddbab42de8a1f6f00b88a2318", + "m_Name": "", + "m_ChildObjectList": [ + { + "m_Id": "9d7ee9e86af1446d8ab1ec1c058ecfee" + }, + { + "m_Id": "e32cc799c0204e05ba1d30c02e3eb720" + }, + { + "m_Id": "44a3b27e93754e2ca9445c452d735073" + }, + { + "m_Id": "0037bf0f4de94a8d885c1c6dac42056c" + }, + { + "m_Id": "6dd2b1faba004a728ed5d208c9efa1c1" + }, + { + "m_Id": "9a1da2cbbb434c87b01edd10819c1b63" + } + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "42d3dca50202402e87aee317b4c4aad9", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "4407911d57974a4f90115a366befe513", + "m_Id": 3, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "44a3b27e93754e2ca9445c452d735073", + "m_Guid": { + "m_GuidSerialized": "cc41f2ad-163d-4620-b8c1-72b0d32d6af5" + }, + "m_Name": "Edge", + "m_DefaultRefNameVersion": 1, + "m_RefNameGeneratedByDisplayName": "Edge", + "m_DefaultReferenceName": "_Edge", + "m_OverrideReferenceName": "", + "m_GeneratePropertyBlock": true, + "m_UseCustomSlotLabel": false, + "m_CustomSlotLabel": "", + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.9850000143051148, + "m_FloatType": 0, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "45670ed8db9245b3a08b06ff7a25e5d8", + "m_Id": 0, + "m_DisplayName": "EdgeThera", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.LerpNode", + "m_ObjectId": "49f4e2d3805240ed9d55247c1be6eeaa", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Lerp", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 1100.0, + "y": 110.99993896484375, + "width": 130.0, + "height": 142.0 + } + }, + "m_Slots": [ + { + "m_Id": "c2f11540790e4a8bb7189a058c0f345a" + }, + { + "m_Id": "a20e204497bf48399d6a247100788a0f" + }, + { + "m_Id": "78c26e7b5838471680561a1e08dac205" + }, + { + "m_Id": "3277987125264aa58a18f8e58e429d05" + } + ], + "synonyms": [ + "mix", + "blend", + "linear interpolate" + ], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "4a1287facb184577900a12f9bef16aa7", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "4a74ac520e96448bbc2d617759a51f8e", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BooleanMaterialSlot", + "m_ObjectId": "4c48cb7ff9894281b6834d47a834242a", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": false, + "m_DefaultValue": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MinimumNode", + "m_ObjectId": "4d66744c089e482db328fcc1135ba68a", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Minimum", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1973.0001220703125, + "y": 111.99998474121094, + "width": 126.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "13583df735e04ca19cdf710a83a1652b" + }, + { + "m_Id": "9b703b0dc6234b4a8f783ffc5b163d3f" + }, + { + "m_Id": "b2f27c80cd8147fb9230907d135a5510" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "4fcd45d42f1f402ab1576c1901326850", + "m_Id": 2, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DivideNode", + "m_ObjectId": "54407f56f36c4fd49af88d89edf8696a", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Divide", + "m_DrawState": { + "m_Expanded": false, + "m_Position": { + "serializedVersion": "2", + "x": -1201.0, + "y": 702.0000610351563, + "width": 130.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "20944635d9f1412dab104114e6a81d1b" + }, + { + "m_Id": "6c29855ca1714b4aa95e24999b48dc98" + }, + { + "m_Id": "013d6bbb0c83407c80f8f5a45e3a203e" + } + ], + "synonyms": [ + "division", + "divided by" + ], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "5579349f2b814168a2a03e20aaaad5c2", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "571e34592f8b4f92969b1b92ff090607", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "57924e6529754609923b1a5f2933cc3a", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 279.9999694824219, + "y": 229.9999542236328, + "width": 132.0, + "height": 34.00001525878906 + } + }, + "m_Slots": [ + { + "m_Id": "45670ed8db9245b3a08b06ff7a25e5d8" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "0037bf0f4de94a8d885c1c6dac42056c" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "57f28b2075c848ac871156ba6051feaa", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2222.000244140625, + "y": 77.99998474121094, + "width": 109.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "1fd369b37c9b40ef9cda54ae5de2d7fe" + } + ], + "synonyms": [], + "m_Precision": 1, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "9d7ee9e86af1446d8ab1ec1c058ecfee" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2MaterialSlot", + "m_ObjectId": "589c80956beb4f769750b0d3ce29eed4", + "m_Id": 0, + "m_DisplayName": "Point2", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "599366d8ea2747a2a74e4b13bb7676e1", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SubtractNode", + "m_ObjectId": "5a3a6d335b24450ab68ca68224bd8040", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Subtract", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 279.9999694824219, + "y": 111.9998779296875, + "width": 130.00003051757813, + "height": 118.00007629394531 + } + }, + "m_Slots": [ + { + "m_Id": "920d2ee36205462ba40b71ad3739e1d6" + }, + { + "m_Id": "fb2d290e65b946ce9abc0e92a3db44cc" + }, + { + "m_Id": "673ce498c4ad4b86be3d8cd9faf27214" + } + ], + "synonyms": [ + "subtraction", + "remove", + "minus", + "take away" + ], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MaximumNode", + "m_ObjectId": "5a5aa7a85fb94e27b4b8d393823e3a3a", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Maximum", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1973.0001220703125, + "y": 348.00006103515627, + "width": 126.0, + "height": 117.99990844726563 + } + }, + "m_Slots": [ + { + "m_Id": "d5296438a5494683834d5b36740bab89" + }, + { + "m_Id": "792b7fce193d4f2aafcb31caf7cd5162" + }, + { + "m_Id": "ec478a87a002472eabeaf6790924f35e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ScreenNode", + "m_ObjectId": "5aded1b2bbdf4ca2b7a5ef92b985adcb", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Screen", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1675.0, + "y": 701.0, + "width": 88.0, + "height": 101.0 + } + }, + "m_Slots": [ + { + "m_Id": "5b68a44e582f4227a8894a4e5b1518c8" + }, + { + "m_Id": "6fa41a3ca42e4f8c8954a02de909c28c" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "5ae91421baa5477c804602c7e3714bf9", + "m_Id": 2, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "5b04c7c2445843f9a45724acdd3dc06c", + "m_Id": 0, + "m_DisplayName": "R", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 3, + "m_Value": 640.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "5b68a44e582f4227a8894a4e5b1518c8", + "m_Id": 0, + "m_DisplayName": "Width", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Width", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BooleanMaterialSlot", + "m_ObjectId": "5c39667aea0f46d3bc2ffa5b459c7622", + "m_Id": 0, + "m_DisplayName": "Predicate", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Predicate", + "m_StageCapability": 3, + "m_Value": false, + "m_DefaultValue": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.VertexColorNode", + "m_ObjectId": "5cdb08742bac484599862b68c1d1284d", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Vertex Color", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 1404.9998779296875, + "y": -571.9999389648438, + "width": 118.0001220703125, + "height": 93.99996948242188 + } + }, + "m_Slots": [ + { + "m_Id": "0fb700d77039488d98f6cbe2470503e4" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 2, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.LerpNode", + "m_ObjectId": "5d87e27df271488f8d357c61ffad3f91", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Lerp", + "m_DrawState": { + "m_Expanded": false, + "m_Position": { + "serializedVersion": "2", + "x": -1592.0001220703125, + "y": 230.00001525878907, + "width": 130.0, + "height": 117.99998474121094 + } + }, + "m_Slots": [ + { + "m_Id": "cf0c03edbe7040f5909e98f2615f97bb" + }, + { + "m_Id": "a981613a3e084f4aa0df48de7249bf27" + }, + { + "m_Id": "be82b00acdde400aaba13712d12f042e" + }, + { + "m_Id": "2058b054ebdc4420b214562023ee8749" + } + ], + "synonyms": [ + "mix", + "blend", + "linear interpolate" + ], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.CustomInterpolatorNode", + "m_ObjectId": "5e8e5336ed634a0fbc5860d58df29c09", + "m_Group": { + "m_Id": "" + }, + "m_Name": "CustomInterpolatorPreVertex (Custom Interpolator)", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 1404.9998779296875, + "y": -707.0, + "width": 338.0, + "height": 94.00006103515625 + } + }, + "m_Slots": [ + { + "m_Id": "8878a7d8809e4a3288866eb1e5b64967" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "customBlockNodeName": "CustomInterpolatorPreVertex", + "serializedType": 4 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "5f4cc034ff7940319ce494ff56fce947", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "607bde7fe5e84817b6dbf7995d5f2ff8", + "m_Id": 4, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "61367601cd49469d9500e8b5e1bf9cff", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "618233005983415c89e0a7289c836914", + "m_Group": { + "m_Id": "" + }, + "m_Name": "VertexDescription.Position", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "35024b2926e048ebbc15c9842f0172b2" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "VertexDescription.Position" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DivideNode", + "m_ObjectId": "61859cf0e65a47d4b0dfab22edd0bf9d", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Divide", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -666.0000610351563, + "y": 203.00006103515626, + "width": 130.0, + "height": 117.99993896484375 + } + }, + "m_Slots": [ + { + "m_Id": "f1608264b8be4339a56e6f7a4dd1dacf" + }, + { + "m_Id": "b5914df1c7c64093a3fadf6f7cb1a6fb" + }, + { + "m_Id": "247503c695d746e6a2da88e9c22ed35b" + } + ], + "synonyms": [ + "division", + "divided by" + ], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "6214f96a5cd94b9ea341b86b2d035b04", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ColorRGBMaterialSlot", + "m_ObjectId": "63874270112b4449b87471fe95a1756f", + "m_Id": 0, + "m_DisplayName": "Base Color", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "BaseColor", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 1.0, + "z": 0.004274129867553711 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_ColorMode": 0, + "m_DefaultColor": { + "r": 0.5, + "g": 0.5, + "b": 0.5, + "a": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "63d81c5c394445f5b488f1cb60910840", + "m_Id": 2, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "63e7eb32cb2e4105829dbbb24ee90eab", + "m_Group": { + "m_Id": "" + }, + "m_Name": "VertexDescription.CustomInterpolator", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "8daae37787da45058aef391168fa65be" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "VertexDescription.CustomInterpolatorPreVertex#4" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.CombineNode", + "m_ObjectId": "6466c63d9353433e889ec7eada999295", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Combine", + "m_DrawState": { + "m_Expanded": false, + "m_Position": { + "serializedVersion": "2", + "x": -1717.0001220703125, + "y": 111.99998474121094, + "width": 140.0, + "height": 166.00001525878907 + } + }, + "m_Slots": [ + { + "m_Id": "af0207288466448a98c39db98dd5bd2b" + }, + { + "m_Id": "6b141e99e2294c89b2c116df92243e21" + }, + { + "m_Id": "6d886cd54fd049c88155302d275385b8" + }, + { + "m_Id": "fa466475bf184ea091faed23ef49e484" + }, + { + "m_Id": "6ac7cb86cd834205b689c6d5641fa016" + }, + { + "m_Id": "304bcc3b99004c89b9d2b3b7262b3169" + }, + { + "m_Id": "90d5dcb05da547f09d186625f795d12e" + } + ], + "synonyms": [ + "append" + ], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "64e9a6c3358044e1b814778e361750d5", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "663fe1a6f70a42c396b41abd6e928b92", + "m_Id": 4, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "673ce498c4ad4b86be3d8cd9faf27214", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "675ef0e6c70d45648fae09f830250ff5", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "67891136c56545138b979b8816d55b40", + "m_Id": 3, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BooleanMaterialSlot", + "m_ObjectId": "693d3d420eaf4ddc8f6bd0252cc7fa3c", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": false, + "m_DefaultValue": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "699e9d5b0855487f8f13942f237b0e61", + "m_Id": 1, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "6ac7cb86cd834205b689c6d5641fa016", + "m_Id": 4, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "6adcfebd8ae840438050c77478fe437c", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "6b141e99e2294c89b2c116df92243e21", + "m_Id": 1, + "m_DisplayName": "G", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "6c29855ca1714b4aa95e24999b48dc98", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 2.0, + "y": 2.0, + "z": 2.0, + "w": 2.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "6c2a8ac87cf94cd5bb9e33af357d876c", + "m_Id": 1, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "6c984010b5b4414b88e304b8fff1558c", + "m_Id": 4, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "6d886cd54fd049c88155302d275385b8", + "m_Id": 2, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BooleanMaterialSlot", + "m_ObjectId": "6db77615d7f04060a31bca5b86625510", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": false, + "m_DefaultValue": false +} + +{ + "m_SGVersion": 3, + "m_Type": "UnityEditor.ShaderGraph.Internal.ColorShaderProperty", + "m_ObjectId": "6dd2b1faba004a728ed5d208c9efa1c1", + "m_Guid": { + "m_GuidSerialized": "2886f724-0a60-4303-91cc-6e652322a514" + }, + "m_Name": "Color", + "m_DefaultRefNameVersion": 1, + "m_RefNameGeneratedByDisplayName": "Color", + "m_DefaultReferenceName": "_Color", + "m_OverrideReferenceName": "", + "m_GeneratePropertyBlock": true, + "m_UseCustomSlotLabel": false, + "m_CustomSlotLabel": "", + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "r": 0.0, + "g": 0.17089080810546876, + "b": 1.0, + "a": 0.0 + }, + "isMainColor": false, + "m_ColorMode": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "6f560bcaaa3e452fa440a497ef419724", + "m_Group": { + "m_Id": "" + }, + "m_Name": "VertexDescription.Normal", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "74f7d92dbbe14ff4a9007ff000a799df" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "VertexDescription.Normal" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.OrNode", + "m_ObjectId": "6f7bbb3dff13474b974352b7eb99af93", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Or", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 673.9999389648438, + "y": 109.99999237060547, + "width": 130.00006103515626, + "height": 100.99991607666016 + } + }, + "m_Slots": [ + { + "m_Id": "693d3d420eaf4ddc8f6bd0252cc7fa3c" + }, + { + "m_Id": "ee40cfe737004d258b3a5dd2583757b5" + }, + { + "m_Id": "c592ed1c4e2147159e9a382bce66b7b3" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "6fa41a3ca42e4f8c8954a02de909c28c", + "m_Id": 1, + "m_DisplayName": "Height", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Height", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "6ffb655c24c04acf948b3dbd47ecf472", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "7046809435754c139d0662b13c9be1ae", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "706e6419f3544c8cbe6b4513577fab71", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "712b66d7d00447739956594821598ef3", + "m_Id": 0, + "m_DisplayName": "EdgeColor", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "7147f9108cef4330a9324469ba504e65", + "m_Id": 3, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 2, + "m_Type": "UnityEditor.Rendering.BuiltIn.ShaderGraph.BuiltInTarget", + "m_ObjectId": "725b3c9a4d7449479dbc9a999017251f", + "m_ActiveSubTarget": { + "m_Id": "a639a18560644f74818e02e432e3b0bc" + }, + "m_AllowMaterialOverride": false, + "m_SurfaceType": 1, + "m_ZWriteControl": 0, + "m_ZTestMode": 4, + "m_AlphaMode": 0, + "m_RenderFace": 2, + "m_AlphaClip": false, + "m_CustomEditorGUI": "" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.NormalMaterialSlot", + "m_ObjectId": "74f7d92dbbe14ff4a9007ff000a799df", + "m_Id": 0, + "m_DisplayName": "Normal", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Normal", + "m_StageCapability": 1, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "78c26e7b5838471680561a1e08dac205", + "m_Id": 2, + "m_DisplayName": "T", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "T", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "78d08c62c8294005bdf49a28d34014dc", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Alpha", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "2de3477aae07402a99be998a67ce2ee6" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Alpha" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SubtractNode", + "m_ObjectId": "78fccb4c15e94754949e901b97d47fab", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Subtract", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1056.0001220703125, + "y": 111.99998474121094, + "width": 130.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "f41a3659b4784ee980a318964cdd3794" + }, + { + "m_Id": "dc55ee4c29144e2cb257a9513cab8d9d" + }, + { + "m_Id": "99e04e86c62d4dd38249e8d0c0c3114b" + } + ], + "synonyms": [ + "subtraction", + "remove", + "minus", + "take away" + ], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "792b7fce193d4f2aafcb31caf7cd5162", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "799a0d80af754a81a268eed7c9429bbb", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "7b4994927f9d436ba8214b9ab82c908d", + "m_Id": 4, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "7bb2d3223a634f5fbbfc8fb2efcc138c", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.BaseColor", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "63874270112b4449b87471fe95a1756f" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.BaseColor" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "7d04b94dd6624150bd1b4e778c82f081", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "7d511e39661947a28a6f833ba03cd339", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -33.00004959106445, + "y": 112.0, + "width": 130.0, + "height": 118.00004577636719 + } + }, + "m_Slots": [ + { + "m_Id": "64e9a6c3358044e1b814778e361750d5" + }, + { + "m_Id": "61367601cd49469d9500e8b5e1bf9cff" + }, + { + "m_Id": "9623c24fb7ce48bd932963e786b698af" + } + ], + "synonyms": [ + "multiplication", + "times", + "x" + ], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "7daeabe3bf134352b782b20dcdb6d9c8", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "7e0efaf8f4a6489b81827f44fbb9bf1e", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ComparisonNode", + "m_ObjectId": "7e173870f2064f2fb02be49bf4fe72e7", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Comparison", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 528.9999389648438, + "y": 246.9999542236328, + "width": 145.0, + "height": 136.00001525878907 + } + }, + "m_Slots": [ + { + "m_Id": "c8e0e2d56ac84e2298b11879a5320309" + }, + { + "m_Id": "29eff7490f964eb7911f0e9c4bd1b87b" + }, + { + "m_Id": "6db77615d7f04060a31bca5b86625510" + } + ], + "synonyms": [ + "equal", + "greater than", + "less than" + ], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_ComparisonType": 2 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.TangentMaterialSlot", + "m_ObjectId": "80dc8008598148718b8e868793a241b0", + "m_Id": 0, + "m_DisplayName": "Tangent", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Tangent", + "m_StageCapability": 1, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SubtractNode", + "m_ObjectId": "812df07afd8d4f929191cee9cc64e09f", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Subtract", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1462.0001220703125, + "y": 313.0000305175781, + "width": 130.0, + "height": 117.99996948242188 + } + }, + "m_Slots": [ + { + "m_Id": "ab42e487991a4989b603b52bed138426" + }, + { + "m_Id": "675ef0e6c70d45648fae09f830250ff5" + }, + { + "m_Id": "f0fc9d8466d04e0a9316c8a6cab2bf59" + } + ], + "synonyms": [ + "subtraction", + "remove", + "minus", + "take away" + ], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MaximumNode", + "m_ObjectId": "8402c7792aeb4b08b975b4b47d096545", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Maximum", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1973.0001220703125, + "y": 465.9999694824219, + "width": 126.0, + "height": 118.00009155273438 + } + }, + "m_Slots": [ + { + "m_Id": "42d3dca50202402e87aee317b4c4aad9" + }, + { + "m_Id": "4a74ac520e96448bbc2d617759a51f8e" + }, + { + "m_Id": "6214f96a5cd94b9ea341b86b2d035b04" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "85c76872b8364de98e2dc051da61b259", + "m_Id": 1, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "8878a7d8809e4a3288866eb1e5b64967", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "8886635a08404259a25732923c2d0ddc", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "8daae37787da45058aef391168fa65be", + "m_Id": 0, + "m_DisplayName": "CustomInterpolatorPreVertex", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "CustomInterpolatorPreVertex", + "m_StageCapability": 1, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SubtractNode", + "m_ObjectId": "9026c55427fc43fe8fbee3890dff1724", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Subtract", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1056.0001220703125, + "y": 348.00006103515627, + "width": 130.0, + "height": 117.99990844726563 + } + }, + "m_Slots": [ + { + "m_Id": "bf510e26351a46c38705a836b616c246" + }, + { + "m_Id": "6ffb655c24c04acf948b3dbd47ecf472" + }, + { + "m_Id": "b5b518a6652e4522b868a17dff51d413" + } + ], + "synonyms": [ + "subtraction", + "remove", + "minus", + "take away" + ], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2MaterialSlot", + "m_ObjectId": "90d5dcb05da547f09d186625f795d12e", + "m_Id": 6, + "m_DisplayName": "RG", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RG", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "920d2ee36205462ba40b71ad3739e1d6", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "926a6c1015cf46c790e2590055fbd759", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVNode", + "m_ObjectId": "9315d54910e0411d8e3d940c21d2bd41", + "m_Group": { + "m_Id": "" + }, + "m_Name": "UV", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1462.0001220703125, + "y": -20.000017166137697, + "width": 145.0001220703125, + "height": 128.99998474121095 + } + }, + "m_Slots": [ + { + "m_Id": "96581a2208834453bde81d0ee0292c6b" + } + ], + "synonyms": [ + "texcoords", + "coords", + "coordinates" + ], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_OutputChannel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MinimumNode", + "m_ObjectId": "931fa242670f465c8e345681f62d4706", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Minimum", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1973.0001220703125, + "y": 229.99998474121095, + "width": 126.0, + "height": 118.00007629394531 + } + }, + "m_Slots": [ + { + "m_Id": "7d04b94dd6624150bd1b4e778c82f081" + }, + { + "m_Id": "1596081c467247fca91f29b4046c3d38" + }, + { + "m_Id": "024ed61ec15142d8819ef6df6a771029" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "9623c24fb7ce48bd932963e786b698af", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "962aad2c22da46f485f8a4d0613e3469", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "964c7f01f6774420ad4d54b78197a264", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 1100.0, + "y": 382.9999694824219, + "width": 126.0001220703125, + "height": 117.99993896484375 + } + }, + "m_Slots": [ + { + "m_Id": "0930a46e9ec7475d9448b7d922d23ad1" + }, + { + "m_Id": "e34c4123691c468faa2ad2c9540bdc4a" + }, + { + "m_Id": "987df9a973ea43b3941fa970f415f75e" + } + ], + "synonyms": [ + "multiplication", + "times", + "x" + ], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "96581a2208834453bde81d0ee0292c6b", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "965b3bc1c6bc44039b9d51567ce75df5", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 848.0000610351563, + "y": 500.9999084472656, + "width": 125.99993896484375, + "height": 118.00009155273438 + } + }, + "m_Slots": [ + { + "m_Id": "1ced1b90f5574558b6fee8dce23c553a" + }, + { + "m_Id": "b8db1a4ddfe24060a0cfc92576257b97" + }, + { + "m_Id": "799a0d80af754a81a268eed7c9429bbb" + } + ], + "synonyms": [ + "multiplication", + "times", + "x" + ], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "987df9a973ea43b3941fa970f415f75e", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BranchNode", + "m_ObjectId": "98f0cba8df5a47c68bbc07fc292dc06a", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Branch", + "m_DrawState": { + "m_Expanded": false, + "m_Position": { + "serializedVersion": "2", + "x": 804.0, + "y": 111.9998779296875, + "width": 170.0, + "height": 94.00015258789063 + } + }, + "m_Slots": [ + { + "m_Id": "5c39667aea0f46d3bc2ffa5b459c7622" + }, + { + "m_Id": "bd0025d5596e4ead982ff388a5d495fd" + }, + { + "m_Id": "c534a14946fc4273a172e26b1f189511" + }, + { + "m_Id": "da33480746314e20800f18597a02694e" + } + ], + "synonyms": [ + "switch", + "if", + "else" + ], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "9985f228f3d24e2195e48eb08d58a0d5", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "99e04e86c62d4dd38249e8d0c0c3114b", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 3, + "m_Type": "UnityEditor.ShaderGraph.Internal.ColorShaderProperty", + "m_ObjectId": "9a1da2cbbb434c87b01edd10819c1b63", + "m_Guid": { + "m_GuidSerialized": "d7a1bce6-6fdf-426d-92d7-46e33e8ff88c" + }, + "m_Name": "EdgeColor", + "m_DefaultRefNameVersion": 1, + "m_RefNameGeneratedByDisplayName": "EdgeColor", + "m_DefaultReferenceName": "_EdgeColor", + "m_OverrideReferenceName": "", + "m_GeneratePropertyBlock": true, + "m_UseCustomSlotLabel": false, + "m_CustomSlotLabel": "", + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "r": 1.0, + "g": 1.0, + "b": 1.0, + "a": 0.0 + }, + "isMainColor": false, + "m_ColorMode": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "9b703b0dc6234b4a8f783ffc5b163d3f", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ComparisonNode", + "m_ObjectId": "9c9b01c30c284447b28c23ee375bb23f", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Comparison", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 528.9999389648438, + "y": 110.99993896484375, + "width": 145.0, + "height": 136.00001525878907 + } + }, + "m_Slots": [ + { + "m_Id": "926a6c1015cf46c790e2590055fbd759" + }, + { + "m_Id": "3fedfbc45fe04019b5101759e9bc10cc" + }, + { + "m_Id": "4c48cb7ff9894281b6834d47a834242a" + } + ], + "synonyms": [ + "equal", + "greater than", + "less than" + ], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_ComparisonType": 2 +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector2ShaderProperty", + "m_ObjectId": "9d7ee9e86af1446d8ab1ec1c058ecfee", + "m_Guid": { + "m_GuidSerialized": "a2fbb62d-7a9b-419f-b5a6-eb3195f4e7d4" + }, + "m_Name": "Point1", + "m_DefaultRefNameVersion": 1, + "m_RefNameGeneratedByDisplayName": "Point1", + "m_DefaultReferenceName": "_Point1", + "m_OverrideReferenceName": "", + "m_GeneratePropertyBlock": true, + "m_UseCustomSlotLabel": false, + "m_CustomSlotLabel": "", + "m_Precision": 1, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "x": 0.10000000149011612, + "y": 0.10000000149011612, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SplitNode", + "m_ObjectId": "9edd1fd03d1741c2bde179115e6b5370", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Split", + "m_DrawState": { + "m_Expanded": false, + "m_Position": { + "serializedVersion": "2", + "x": 848.0000610351563, + "y": 423.9999084472656, + "width": 118.9998779296875, + "height": 77.0 + } + }, + "m_Slots": [ + { + "m_Id": "1bc4750e64b34fd493653746316c400c" + }, + { + "m_Id": "085efa9bb1df48b0ac252017d6ccc0ca" + }, + { + "m_Id": "f8030853d0ac47efa2396af211f60957" + }, + { + "m_Id": "b3e60be5a17f4d139b7a706ff939cdf9" + }, + { + "m_Id": "6c984010b5b4414b88e304b8fff1558c" + } + ], + "synonyms": [ + "separate" + ], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "9f9439dea65849e9b89aa524efe4b8ce", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "a0e85c82db424faba0dbbf2452e9b4c2", + "m_Id": 3, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "a20e204497bf48399d6a247100788a0f", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "a326ea6261b74ad2bc375d566c42ce90", + "m_Id": 0, + "m_DisplayName": "Color", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.BuiltIn.ShaderGraph.BuiltInUnlitSubTarget", + "m_ObjectId": "a639a18560644f74818e02e432e3b0bc" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.CombineNode", + "m_ObjectId": "a7d7e10a1b994d50a5318b247bde6e99", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Combine", + "m_DrawState": { + "m_Expanded": false, + "m_Position": { + "serializedVersion": "2", + "x": -1587.0, + "y": 701.0, + "width": 125.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "5b04c7c2445843f9a45724acdd3dc06c" + }, + { + "m_Id": "29142e3939a441868f6f5246e839d5d9" + }, + { + "m_Id": "4fcd45d42f1f402ab1576c1901326850" + }, + { + "m_Id": "4407911d57974a4f90115a366befe513" + }, + { + "m_Id": "1e39188f9e1649628293001eb99291ba" + }, + { + "m_Id": "d63ff95202264c3fa372e47108f27bab" + }, + { + "m_Id": "efe4615e1c6345618b97030085823600" + } + ], + "synonyms": [ + "append" + ], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "a837e20966b645c4bd1e5ac3c5a1fe8e", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "a981613a3e084f4aa0df48de7249bf27", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "a9c305554f2648c3b0cf10d8e5f0f241", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1332.0001220703125, + "y": 230.00001525878907, + "width": 130.0, + "height": 117.99998474121094 + } + }, + "m_Slots": [ + { + "m_Id": "e1c8317ae3db4156bec11d93e42c1ab3" + }, + { + "m_Id": "7046809435754c139d0662b13c9be1ae" + }, + { + "m_Id": "9985f228f3d24e2195e48eb08d58a0d5" + } + ], + "synonyms": [ + "multiplication", + "times", + "x" + ], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "ab42e487991a4989b603b52bed138426", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "ac092cd90d8b4f368b5865e2e2ea91a6", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MinimumNode", + "m_ObjectId": "ac4cfe70546d4159a58e1cce895bb482", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Minimum", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -287.0, + "y": 202.99998474121095, + "width": 125.99998474121094, + "height": 117.99998474121094 + } + }, + "m_Slots": [ + { + "m_Id": "8886635a08404259a25732923c2d0ddc" + }, + { + "m_Id": "599366d8ea2747a2a74e4b13bb7676e1" + }, + { + "m_Id": "edaaebd02d5e494e92bfec6011ea4a69" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "af0207288466448a98c39db98dd5bd2b", + "m_Id": 0, + "m_DisplayName": "R", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "af0e0776399b42c1a2cd8876d4334202", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.AddNode", + "m_ObjectId": "b0ffcfa3615f451abf62e7f6b171170d", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Add", + "m_DrawState": { + "m_Expanded": false, + "m_Position": { + "serializedVersion": "2", + "x": 1934.9998779296875, + "y": -707.0, + "width": 69.0, + "height": 94.00006103515625 + } + }, + "m_Slots": [ + { + "m_Id": "dbd15bd6c49e427fa4104030a47eb9bb" + }, + { + "m_Id": "e95a9af8eee9428e8dccf24b7ecd84f3" + }, + { + "m_Id": "a837e20966b645c4bd1e5ac3c5a1fe8e" + } + ], + "synonyms": [ + "addition", + "sum", + "plus" + ], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "b21d4ff4c92f4513bb21347382e47019", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "b2f27c80cd8147fb9230907d135a5510", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "b3e60be5a17f4d139b7a706ff939cdf9", + "m_Id": 3, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "b4aca0fb6e114314928be6fa22e3717e", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "b5914df1c7c64093a3fadf6f7cb1a6fb", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 0.09000000357627869, + "y": 0.09000000357627869, + "z": 2.0, + "w": 2.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "b5b518a6652e4522b868a17dff51d413", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SplitNode", + "m_ObjectId": "b6d5b9e00f1040c0b71de21ad2ee1273", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Split", + "m_DrawState": { + "m_Expanded": false, + "m_Position": { + "serializedVersion": "2", + "x": 410.0, + "y": 110.99993896484375, + "width": 118.99993896484375, + "height": 101.00007629394531 + } + }, + "m_Slots": [ + { + "m_Id": "2d783bd53df94c1ca5ff994a0ab1a429" + }, + { + "m_Id": "85c76872b8364de98e2dc051da61b259" + }, + { + "m_Id": "5ae91421baa5477c804602c7e3714bf9" + }, + { + "m_Id": "422a1a3ab9204aafbfb3ffc28e589967" + }, + { + "m_Id": "1d6cca8f50814d7a88571cf30e0bdd46" + } + ], + "synonyms": [ + "separate" + ], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "b769e980ed79405ca62b3e7bce97b953", + "m_Id": 2, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "b8db1a4ddfe24060a0cfc92576257b97", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "babd9bfbe8dd4dc494543a2ee21b38e6", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2222.000244140625, + "y": 432.0000305175781, + "width": 110.000244140625, + "height": 34.000030517578128 + } + }, + "m_Slots": [ + { + "m_Id": "589c80956beb4f769750b0d3ce29eed4" + } + ], + "synonyms": [], + "m_Precision": 1, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "e32cc799c0204e05ba1d30c02e3eb720" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "bd0025d5596e4ead982ff388a5d495fd", + "m_Id": 1, + "m_DisplayName": "True", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "True", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "bd7b025dc417461088d2c1f8b88f67fc", + "m_Id": 1, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "bdcf27d77d944f7da5f9efd519bc8326", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "be82b00acdde400aaba13712d12f042e", + "m_Id": 2, + "m_DisplayName": "T", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "T", + "m_StageCapability": 3, + "m_Value": { + "x": 0.5, + "y": 0.5, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "becac710070447b9998c640490b19c95", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "bf1d4b549e0b48ae9133c646a125b639", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "bf510e26351a46c38705a836b616c246", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "bfa2dc825b7f4bd7bb3076e3c83cb90a", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "c0ac66db38b94dde8f5a10766837cf5b", + "m_Id": 1, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "c2da02f30d58454a839b8ea2ab088a9e", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -926.0001220703125, + "y": 111.99998474121094, + "width": 130.00006103515626, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "d362cc7771b4473697ae03c2b7db590c" + }, + { + "m_Id": "b4aca0fb6e114314928be6fa22e3717e" + }, + { + "m_Id": "bdcf27d77d944f7da5f9efd519bc8326" + } + ], + "synonyms": [ + "multiplication", + "times", + "x" + ], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "c2f11540790e4a8bb7189a058c0f345a", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "c4d83597b77a47e0ba14a5dbf5460278", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 1100.0, + "y": 41.99998474121094, + "width": 105.0, + "height": 34.00000762939453 + } + }, + "m_Slots": [ + { + "m_Id": "0fc25573d0fc4629ac8d69f5bb434200" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "6dd2b1faba004a728ed5d208c9efa1c1" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "c534a14946fc4273a172e26b1f189511", + "m_Id": 2, + "m_DisplayName": "False", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "False", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BooleanMaterialSlot", + "m_ObjectId": "c592ed1c4e2147159e9a382bce66b7b3", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": false, + "m_DefaultValue": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "c5f46bf6e45c4fbbb0bfcc3c2b9cdeef", + "m_Id": 1, + "m_DisplayName": "G", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "c8e0e2d56ac84e2298b11879a5320309", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "cc7e8eaaae98478994a970d75363f64b", + "m_Id": 4, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "cf0c03edbe7040f5909e98f2615f97bb", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "cf75c9643f7a44bd83d6285125195f2a", + "m_Id": 2, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "cfae2a2a50f34b649ce8e7e43e4784e4", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 974.0, + "y": 382.9999694824219, + "width": 126.0, + "height": 117.99993896484375 + } + }, + "m_Slots": [ + { + "m_Id": "962aad2c22da46f485f8a4d0613e3469" + }, + { + "m_Id": "e348553789874629aaf5ef9ce8002200" + }, + { + "m_Id": "9f9439dea65849e9b89aa524efe4b8ce" + } + ], + "synonyms": [ + "multiplication", + "times", + "x" + ], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SubtractNode", + "m_ObjectId": "d199153182574e7186e7cd7aaf23e9b3", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Subtract", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1462.0, + "y": 584.0000610351563, + "width": 130.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "3c52bece8d464ac59e255f0eb73927c9" + }, + { + "m_Id": "7daeabe3bf134352b782b20dcdb6d9c8" + }, + { + "m_Id": "0ffc67215ae84d64803fafe4adde6320" + } + ], + "synonyms": [ + "subtraction", + "remove", + "minus", + "take away" + ], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "d362cc7771b4473697ae03c2b7db590c", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "d5296438a5494683834d5b36740bab89", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SplitNode", + "m_ObjectId": "d541d33009844984a3a929cb08909fb3", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Split", + "m_DrawState": { + "m_Expanded": false, + "m_Position": { + "serializedVersion": "2", + "x": 1100.0, + "y": 306.0, + "width": 119.0, + "height": 76.99996948242188 + } + }, + "m_Slots": [ + { + "m_Id": "1fdc892bb55545a2b4a442938eced5a4" + }, + { + "m_Id": "c0ac66db38b94dde8f5a10766837cf5b" + }, + { + "m_Id": "b769e980ed79405ca62b3e7bce97b953" + }, + { + "m_Id": "fb8b01dda12647dfac26f0d7adc03525" + }, + { + "m_Id": "cc7e8eaaae98478994a970d75363f64b" + } + ], + "synonyms": [ + "separate" + ], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "d63ff95202264c3fa372e47108f27bab", + "m_Id": 5, + "m_DisplayName": "RGB", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGB", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "da33480746314e20800f18597a02694e", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "db6a09bd547142099e2279980c5b54d0", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1071.0, + "y": 668.0, + "width": 101.99993896484375, + "height": 34.00006103515625 + } + }, + "m_Slots": [ + { + "m_Id": "0a313b7dc94042c6999a4f6af9f25848" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "44a3b27e93754e2ca9445c452d735073" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "dbd15bd6c49e427fa4104030a47eb9bb", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "dc55ee4c29144e2cb257a9513cab8d9d", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "e0896f5d9442475596126b72d32015dc", + "m_Id": 0, + "m_DisplayName": "R", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "e13ec1cd374440c4afe1c85ae39f67a3", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "e1c8317ae3db4156bec11d93e42c1ab3", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector2ShaderProperty", + "m_ObjectId": "e32cc799c0204e05ba1d30c02e3eb720", + "m_Guid": { + "m_GuidSerialized": "8dadd267-4962-4fb5-9781-2eb1b468e3ae" + }, + "m_Name": "Point2", + "m_DefaultRefNameVersion": 1, + "m_RefNameGeneratedByDisplayName": "Point2", + "m_DefaultReferenceName": "_Point2", + "m_OverrideReferenceName": "", + "m_GeneratePropertyBlock": true, + "m_UseCustomSlotLabel": false, + "m_CustomSlotLabel": "", + "m_Precision": 1, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "x": 0.5, + "y": 0.800000011920929, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "e348553789874629aaf5ef9ce8002200", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "e34c4123691c468faa2ad2c9540bdc4a", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SignNode", + "m_ObjectId": "e43d15309eee469899e39c52487f5717", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Sign", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -160.9999542236328, + "y": 202.99996948242188, + "width": 127.99996185302735, + "height": 94.00003051757813 + } + }, + "m_Slots": [ + { + "m_Id": "1ae51bb4ac7f4510bcde3b70e23d8548" + }, + { + "m_Id": "5579349f2b814168a2a03e20aaaad5c2" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "e95a9af8eee9428e8dccf24b7ecd84f3", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "ec478a87a002472eabeaf6790924f35e", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "edaaebd02d5e494e92bfec6011ea4a69", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BooleanMaterialSlot", + "m_ObjectId": "ee40cfe737004d258b3a5dd2583757b5", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": false, + "m_DefaultValue": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "ee6cf9ccc94545e3890adefbba78c0d9", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "ef090b7af48f406f97b34882f60fe768", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2MaterialSlot", + "m_ObjectId": "efa6dbf958c043078d6fb1e41d1092bf", + "m_Id": 6, + "m_DisplayName": "RG", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RG", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2MaterialSlot", + "m_ObjectId": "efe4615e1c6345618b97030085823600", + "m_Id": 6, + "m_DisplayName": "RG", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RG", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "f0fc9d8466d04e0a9316c8a6cab2bf59", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "f1608264b8be4339a56e6f7a4dd1dacf", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "f1ad687730c84a98aec04547082f7b72", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "f41a3659b4784ee980a318964cdd3794", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "f69fada9ab80444e8f3160b51e732613", + "m_Id": 2, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "f8030853d0ac47efa2396af211f60957", + "m_Id": 2, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "f897f715292a45a391d817a048261657", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1071.0, + "y": 702.0000610351563, + "width": 130.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "f8f0d35c664647f4aadcd60f9341dda6" + }, + { + "m_Id": "e13ec1cd374440c4afe1c85ae39f67a3" + }, + { + "m_Id": "af0e0776399b42c1a2cd8876d4334202" + } + ], + "synonyms": [ + "multiplication", + "times", + "x" + ], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "f8f0d35c664647f4aadcd60f9341dda6", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "fa466475bf184ea091faed23ef49e484", + "m_Id": 3, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "fb2d290e65b946ce9abc0e92a3db44cc", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0010000000474974514, + "y": 0.0010000000474974514, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "fb8b01dda12647dfac26f0d7adc03525", + "m_Id": 3, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "fd32acfe2a3040f9b19074bb36a417e4", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 1100.0, + "y": 75.99999237060547, + "width": 132.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "712b66d7d00447739956594821598ef3" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "9a1da2cbbb434c87b01edd10819c1b63" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "fdcbfa10eba048faad43b3da6d7225e3", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + diff --git a/Resources/Meshs/EditorTool/6m高立方体.fbx b/Resources/Meshs/EditorTool/6m高立方体.fbx new file mode 100644 index 0000000000000000000000000000000000000000..913aaec966687c58b7f7856087a631ade89cd98a GIT binary patch literal 15180 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 U&$_(#&q6ESXcYPFpW5gD0Lj}Eg#Z8m literal 0 HcmV?d00001 diff --git a/Resources/Prefab/ConfigUIItem/ConfigDigiteInput.prefab b/Resources/Prefab/ConfigUIItem/ConfigDigiteInput.prefab new file mode 100644 index 0000000..96707db --- /dev/null +++ b/Resources/Prefab/ConfigUIItem/ConfigDigiteInput.prefab @@ -0,0 +1,1416 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!1 &6020133344334338800 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 8040101714722564985} + - component: {fileID: 5039833503221258314} + - component: {fileID: 4082521950945455002} + m_Layer: 5 + m_Name: help + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &8040101714722564985 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 6020133344334338800} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: [] + m_Father: {fileID: 7324063016638379250} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 1} + m_AnchorMax: {x: 0, y: 1} + m_AnchoredPosition: {x: 0, y: -35} + m_SizeDelta: {x: 300, y: 50} + m_Pivot: {x: 0, y: 1} +--- !u!222 &5039833503221258314 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 6020133344334338800} + m_CullTransparentMesh: 1 +--- !u!114 &4082521950945455002 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 6020133344334338800} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: f4688fdb7df04437aeb418b961361dc5, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_text: + m_isRightToLeft: 0 + m_fontAsset: {fileID: 11400000, guid: 3bd21f304e77db54eb98a1f35f6a2680, type: 2} + m_sharedMaterial: {fileID: -3509209986637506031, guid: 3bd21f304e77db54eb98a1f35f6a2680, type: 2} + m_fontSharedMaterials: [] + m_fontMaterial: {fileID: 0} + m_fontMaterials: [] + m_fontColor32: + serializedVersion: 2 + rgba: 4278190335 + m_fontColor: {r: 1, g: 0, b: 0, a: 1} + m_enableVertexGradient: 0 + m_colorMode: 3 + m_fontColorGradient: + topLeft: {r: 1, g: 1, b: 1, a: 1} + topRight: {r: 1, g: 1, b: 1, a: 1} + bottomLeft: {r: 1, g: 1, b: 1, a: 1} + bottomRight: {r: 1, g: 1, b: 1, a: 1} + m_fontColorGradientPreset: {fileID: 0} + m_spriteAsset: {fileID: 0} + m_tintAllSprites: 0 + m_StyleSheet: {fileID: 0} + m_TextStyleHashCode: -1183493901 + m_overrideHtmlColors: 0 + m_faceColor: + serializedVersion: 2 + rgba: 4294967295 + m_fontSize: 14 + m_fontSizeBase: 14 + m_fontWeight: 400 + m_enableAutoSizing: 0 + m_fontSizeMin: 18 + m_fontSizeMax: 72 + m_fontStyle: 0 + m_HorizontalAlignment: 1 + m_VerticalAlignment: 256 + m_textAlignment: 65535 + m_characterSpacing: 0 + m_wordSpacing: 0 + m_lineSpacing: 0 + m_lineSpacingMax: 0 + m_paragraphSpacing: 0 + m_charWidthMaxAdj: 0 + m_enableWordWrapping: 1 + m_wordWrappingRatios: 0.4 + m_overflowMode: 0 + m_linkedTextComponent: {fileID: 0} + parentLinkedComponent: {fileID: 0} + m_enableKerning: 1 + m_enableExtraPadding: 0 + checkPaddingRequired: 0 + m_isRichText: 1 + m_parseCtrlCharacters: 1 + m_isOrthographic: 1 + m_isCullingEnabled: 0 + m_horizontalMapping: 0 + m_verticalMapping: 0 + m_uvLineOffset: 0 + m_geometrySortingOrder: 0 + m_IsTextObjectScaleStatic: 0 + m_VertexBufferAutoSizeReduction: 0 + m_useMaxVisibleDescender: 1 + m_pageToDisplay: 1 + m_margin: {x: 0, y: 0, z: 0, w: 0} + m_isUsingLegacyAnimationComponent: 0 + m_isVolumetricText: 0 + m_hasFontAssetChanged: 0 + m_baseMaterial: {fileID: 0} + m_maskOffset: {x: 0, y: 0, z: 0, w: 0} +--- !u!1 &7933913440620816631 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 7933913440620816630} + - component: {fileID: 7933913440620816625} + m_Layer: 5 + m_Name: Toggle + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &7933913440620816630 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 7933913440620816631} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: + - {fileID: 7933913441394453803} + - {fileID: 7933913440750380166} + m_Father: {fileID: 7933913441054708338} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0.5} + m_AnchorMax: {x: 0, y: 0.5} + m_AnchoredPosition: {x: 0, y: -0.000015258789} + m_SizeDelta: {x: 16, y: 16} + m_Pivot: {x: 0, y: 0.5} +--- !u!114 &7933913440620816625 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 7933913440620816631} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 9085046f02f69544eb97fd06b6048fe2, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Navigation: + m_Mode: 3 + m_WrapAround: 0 + m_SelectOnUp: {fileID: 0} + m_SelectOnDown: {fileID: 0} + m_SelectOnLeft: {fileID: 0} + m_SelectOnRight: {fileID: 0} + m_Transition: 1 + m_Colors: + m_NormalColor: {r: 1, g: 1, b: 1, a: 1} + m_HighlightedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} + m_PressedColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 1} + m_SelectedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} + m_DisabledColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 0.5019608} + m_ColorMultiplier: 1 + m_FadeDuration: 0.1 + m_SpriteState: + m_HighlightedSprite: {fileID: 0} + m_PressedSprite: {fileID: 0} + m_SelectedSprite: {fileID: 0} + m_DisabledSprite: {fileID: 0} + m_AnimationTriggers: + m_NormalTrigger: Normal + m_HighlightedTrigger: Highlighted + m_PressedTrigger: Pressed + m_SelectedTrigger: Selected + m_DisabledTrigger: Disabled + m_Interactable: 1 + m_TargetGraphic: {fileID: 7933913441394453802} + toggleTransition: 1 + graphic: {fileID: 7933913440750380161} + m_Group: {fileID: 0} + onValueChanged: + m_PersistentCalls: + m_Calls: [] + m_IsOn: 0 +--- !u!1 &7933913440750380167 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 7933913440750380166} + - component: {fileID: 7933913440750380160} + - component: {fileID: 7933913440750380161} + m_Layer: 5 + m_Name: Checkmark + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &7933913440750380166 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 7933913440750380167} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: [] + m_Father: {fileID: 7933913440620816630} + m_RootOrder: 1 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: -0.00000014901161, y: 0.00000013579847} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &7933913440750380160 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 7933913440750380167} + m_CullTransparentMesh: 1 +--- !u!114 &7933913440750380161 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 7933913440750380167} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_Sprite: {fileID: 21300000, guid: 1f2a868175c8a8a47a887eea9056fe28, type: 3} + m_Type: 0 + m_PreserveAspect: 0 + m_FillCenter: 1 + m_FillMethod: 4 + m_FillAmount: 1 + m_FillClockwise: 1 + m_FillOrigin: 0 + m_UseSpriteMesh: 0 + m_PixelsPerUnitMultiplier: 1 +--- !u!1 &7933913441054708339 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 7933913441054708338} + m_Layer: 5 + m_Name: toggle + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &7933913441054708338 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 7933913441054708339} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: + - {fileID: 7933913440620816630} + m_Father: {fileID: 8444637014727969524} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 0, y: 0} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 22, y: 40} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!1 &7933913441394453800 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 7933913441394453803} + - component: {fileID: 7933913441394453813} + - component: {fileID: 7933913441394453802} + m_Layer: 5 + m_Name: Background + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &7933913441394453803 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 7933913441394453800} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: [] + m_Father: {fileID: 7933913440620816630} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0.03426361, y: 0.00049591064} + m_SizeDelta: {x: 0.065603256, y: 0.00012207031} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &7933913441394453813 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 7933913441394453800} + m_CullTransparentMesh: 1 +--- !u!114 &7933913441394453802 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 7933913441394453800} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_Sprite: {fileID: 21300000, guid: 56a95a2d9d13e774093a51bcbebb8e7f, type: 3} + m_Type: 0 + m_PreserveAspect: 0 + m_FillCenter: 1 + m_FillMethod: 4 + m_FillAmount: 1 + m_FillClockwise: 1 + m_FillOrigin: 0 + m_UseSpriteMesh: 0 + m_PixelsPerUnitMultiplier: 1 +--- !u!1 &8118933799207693674 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 7324063016638379250} + - component: {fileID: 1397148291642722205} + - component: {fileID: 1370667499329998716} + m_Layer: 5 + m_Name: title + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &7324063016638379250 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 8118933799207693674} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: + - {fileID: 8040101714722564985} + m_Father: {fileID: 8444637014727969524} + m_RootOrder: 1 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 0, y: 0} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 120, y: 40} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &1397148291642722205 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 8118933799207693674} + m_CullTransparentMesh: 1 +--- !u!114 &1370667499329998716 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 8118933799207693674} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: f4688fdb7df04437aeb418b961361dc5, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_text: + m_isRightToLeft: 0 + m_fontAsset: {fileID: 11400000, guid: 3bd21f304e77db54eb98a1f35f6a2680, type: 2} + m_sharedMaterial: {fileID: -3509209986637506031, guid: 3bd21f304e77db54eb98a1f35f6a2680, type: 2} + m_fontSharedMaterials: [] + m_fontMaterial: {fileID: 0} + m_fontMaterials: [] + m_fontColor32: + serializedVersion: 2 + rgba: 4278190080 + m_fontColor: {r: 0, g: 0, b: 0, a: 1} + m_enableVertexGradient: 0 + m_colorMode: 3 + m_fontColorGradient: + topLeft: {r: 1, g: 1, b: 1, a: 1} + topRight: {r: 1, g: 1, b: 1, a: 1} + bottomLeft: {r: 1, g: 1, b: 1, a: 1} + bottomRight: {r: 1, g: 1, b: 1, a: 1} + m_fontColorGradientPreset: {fileID: 0} + m_spriteAsset: {fileID: 0} + m_tintAllSprites: 0 + m_StyleSheet: {fileID: 0} + m_TextStyleHashCode: -1183493901 + m_overrideHtmlColors: 0 + m_faceColor: + serializedVersion: 2 + rgba: 4294967295 + m_fontSize: 16 + m_fontSizeBase: 16 + m_fontWeight: 400 + m_enableAutoSizing: 0 + m_fontSizeMin: 18 + m_fontSizeMax: 72 + m_fontStyle: 0 + m_HorizontalAlignment: 1 + m_VerticalAlignment: 512 + m_textAlignment: 65535 + m_characterSpacing: 0 + m_wordSpacing: 0 + m_lineSpacing: 0 + m_lineSpacingMax: 0 + m_paragraphSpacing: 0 + m_charWidthMaxAdj: 0 + m_enableWordWrapping: 1 + m_wordWrappingRatios: 0.4 + m_overflowMode: 0 + m_linkedTextComponent: {fileID: 0} + parentLinkedComponent: {fileID: 0} + m_enableKerning: 1 + m_enableExtraPadding: 0 + checkPaddingRequired: 0 + m_isRichText: 1 + m_parseCtrlCharacters: 1 + m_isOrthographic: 1 + m_isCullingEnabled: 0 + m_horizontalMapping: 0 + m_verticalMapping: 0 + m_uvLineOffset: 0 + m_geometrySortingOrder: 0 + m_IsTextObjectScaleStatic: 0 + m_VertexBufferAutoSizeReduction: 0 + m_useMaxVisibleDescender: 1 + m_pageToDisplay: 1 + m_margin: {x: 0, y: -1.5838165, z: 0, w: 0} + m_isUsingLegacyAnimationComponent: 0 + m_isVolumetricText: 0 + m_hasFontAssetChanged: 0 + m_baseMaterial: {fileID: 0} + m_maskOffset: {x: 0, y: 0, z: 0, w: 0} +--- !u!1 &8444637014727969525 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 8444637014727969524} + - component: {fileID: 8444637014727969527} + - component: {fileID: 8444637014727969526} + m_Layer: 5 + m_Name: ConfigDigiteInput + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &8444637014727969524 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 8444637014727969525} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: + - {fileID: 7933913441054708338} + - {fileID: 7324063016638379250} + - {fileID: 8444637015306566401} + - {fileID: 8444637016535975175} + - {fileID: 5520907964103984873} + m_Father: {fileID: 0} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0.5, y: 1} + m_AnchorMax: {x: 0.5, y: 1} + m_AnchoredPosition: {x: -100, y: -150} + m_SizeDelta: {x: 320, y: 40} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!114 &8444637014727969527 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 8444637014727969525} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: d84fd414ac6743e46909249427b18364, type: 3} + m_Name: + m_EditorClassIdentifier: + configTag: + allowInput: 1 + autoUpdateValue: 1 + allowBlockUpdate: 1 + forceBlockUpdate: 0 + numberFormat: 0.## + titleLabel: {fileID: 1370667499329998716} + titleTextContext: + helpLabel: {fileID: 4082521950945455002} + helpTextContext: + unitLabel: {fileID: 0} + unitTextContext: + autoUpdateValueToggle: {fileID: 7933913440620816625} + autoUpdateValueToggleReversalState: 0 + autoUpdateValueReversalState: 1 + dirtyAutoReset: 0 + editorInput: 0 + targetInput: {fileID: 8444637016535975174} + digitalAddButton: {fileID: 382614920130264398} + digitalSubButton: {fileID: 8444637015306566400} + maxValue: 114514 + minValue: -114514 + digits: 2 + delta: 1 +--- !u!114 &8444637014727969526 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 8444637014727969525} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 30649d3a9faa99c48a7b1166b86bf2a0, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Padding: + m_Left: 0 + m_Right: 0 + m_Top: 0 + m_Bottom: 0 + m_ChildAlignment: 3 + m_Spacing: 0 + m_ChildForceExpandWidth: 1 + m_ChildForceExpandHeight: 1 + m_ChildControlWidth: 0 + m_ChildControlHeight: 0 + m_ChildScaleWidth: 0 + m_ChildScaleHeight: 0 + m_ReverseArrangement: 0 +--- !u!1 &8444637015306566402 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 8444637015306566401} + - component: {fileID: 8444637015306566406} + - component: {fileID: 8444637015306566407} + - component: {fileID: 8444637015306566400} + m_Layer: 5 + m_Name: subbutton + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &8444637015306566401 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 8444637015306566402} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: [] + m_Father: {fileID: 8444637014727969524} + m_RootOrder: 2 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 0, y: 0} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 35, y: 35} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &8444637015306566406 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 8444637015306566402} + m_CullTransparentMesh: 1 +--- !u!114 &8444637015306566407 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 8444637015306566402} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_Sprite: {fileID: 21300000, guid: eb971cbde68bfb742b8ca58590c091fd, type: 3} + m_Type: 0 + m_PreserveAspect: 0 + m_FillCenter: 1 + m_FillMethod: 4 + m_FillAmount: 1 + m_FillClockwise: 1 + m_FillOrigin: 0 + m_UseSpriteMesh: 0 + m_PixelsPerUnitMultiplier: 1 +--- !u!114 &8444637015306566400 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 8444637015306566402} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 4e29b1a8efbd4b44bb3f3716e73f07ff, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Navigation: + m_Mode: 3 + m_WrapAround: 0 + m_SelectOnUp: {fileID: 0} + m_SelectOnDown: {fileID: 0} + m_SelectOnLeft: {fileID: 0} + m_SelectOnRight: {fileID: 0} + m_Transition: 1 + m_Colors: + m_NormalColor: {r: 1, g: 1, b: 1, a: 1} + m_HighlightedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} + m_PressedColor: {r: 0.40650588, g: 0.7546515, b: 0.990566, a: 1} + m_SelectedColor: {r: 1, g: 1, b: 1, a: 1} + m_DisabledColor: {r: 1, g: 1, b: 1, a: 1} + m_ColorMultiplier: 1 + m_FadeDuration: 0.1 + m_SpriteState: + m_HighlightedSprite: {fileID: 0} + m_PressedSprite: {fileID: 0} + m_SelectedSprite: {fileID: 0} + m_DisabledSprite: {fileID: 0} + m_AnimationTriggers: + m_NormalTrigger: Normal + m_HighlightedTrigger: Highlighted + m_PressedTrigger: Pressed + m_SelectedTrigger: Selected + m_DisabledTrigger: Disabled + m_Interactable: 1 + m_TargetGraphic: {fileID: 8444637015306566407} + m_OnClick: + m_PersistentCalls: + m_Calls: [] +--- !u!1 &8444637015474898728 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 8444637015474898735} + - component: {fileID: 8444637015474898733} + - component: {fileID: 8444637015474898734} + m_Layer: 5 + m_Name: Text + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &8444637015474898735 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 8444637015474898728} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: [] + m_Father: {fileID: 8444637016306948239} + m_RootOrder: 1 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 0, y: 0} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &8444637015474898733 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 8444637015474898728} + m_CullTransparentMesh: 1 +--- !u!114 &8444637015474898734 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 8444637015474898728} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: f4688fdb7df04437aeb418b961361dc5, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_text: "NAN\u200B" + m_isRightToLeft: 0 + m_fontAsset: {fileID: 11400000, guid: 713219d18e2f8c440b4e4435211afb23, type: 2} + m_sharedMaterial: {fileID: -1567122069935691074, guid: 713219d18e2f8c440b4e4435211afb23, type: 2} + m_fontSharedMaterials: [] + m_fontMaterial: {fileID: 0} + m_fontMaterials: [] + m_fontColor32: + serializedVersion: 2 + rgba: 4281479730 + m_fontColor: {r: 0.19607843, g: 0.19607843, b: 0.19607843, a: 1} + m_enableVertexGradient: 0 + m_colorMode: 3 + m_fontColorGradient: + topLeft: {r: 1, g: 1, b: 1, a: 1} + topRight: {r: 1, g: 1, b: 1, a: 1} + bottomLeft: {r: 1, g: 1, b: 1, a: 1} + bottomRight: {r: 1, g: 1, b: 1, a: 1} + m_fontColorGradientPreset: {fileID: 0} + m_spriteAsset: {fileID: 0} + m_tintAllSprites: 0 + m_StyleSheet: {fileID: 0} + m_TextStyleHashCode: -1183493901 + m_overrideHtmlColors: 0 + m_faceColor: + serializedVersion: 2 + rgba: 4294967295 + m_fontSize: 14 + m_fontSizeBase: 14 + m_fontWeight: 400 + m_enableAutoSizing: 0 + m_fontSizeMin: 18 + m_fontSizeMax: 72 + m_fontStyle: 0 + m_HorizontalAlignment: 2 + m_VerticalAlignment: 512 + m_textAlignment: 65535 + m_characterSpacing: 0 + m_wordSpacing: 0 + m_lineSpacing: 0 + m_lineSpacingMax: 0 + m_paragraphSpacing: 0 + m_charWidthMaxAdj: 0 + m_enableWordWrapping: 0 + m_wordWrappingRatios: 0.4 + m_overflowMode: 0 + m_linkedTextComponent: {fileID: 0} + parentLinkedComponent: {fileID: 0} + m_enableKerning: 1 + m_enableExtraPadding: 1 + checkPaddingRequired: 0 + m_isRichText: 1 + m_parseCtrlCharacters: 1 + m_isOrthographic: 1 + m_isCullingEnabled: 0 + m_horizontalMapping: 0 + m_verticalMapping: 0 + m_uvLineOffset: 0 + m_geometrySortingOrder: 0 + m_IsTextObjectScaleStatic: 0 + m_VertexBufferAutoSizeReduction: 0 + m_useMaxVisibleDescender: 1 + m_pageToDisplay: 1 + m_margin: {x: 0, y: 0, z: 0, w: 0} + m_isUsingLegacyAnimationComponent: 0 + m_isVolumetricText: 0 + m_hasFontAssetChanged: 0 + m_baseMaterial: {fileID: 0} + m_maskOffset: {x: 0, y: 0, z: 0, w: 0} +--- !u!1 &8444637016276988761 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 8444637016276988760} + - component: {fileID: 8444637016276988765} + - component: {fileID: 8444637016276988766} + - component: {fileID: 8444637016276988767} + m_Layer: 5 + m_Name: Placeholder + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 0 +--- !u!224 &8444637016276988760 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 8444637016276988761} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: [] + m_Father: {fileID: 8444637016306948239} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 0, y: 0} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &8444637016276988765 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 8444637016276988761} + m_CullTransparentMesh: 1 +--- !u!114 &8444637016276988766 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 8444637016276988761} + m_Enabled: 0 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: f4688fdb7df04437aeb418b961361dc5, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_text: 125 + m_isRightToLeft: 0 + m_fontAsset: {fileID: 11400000, guid: 713219d18e2f8c440b4e4435211afb23, type: 2} + m_sharedMaterial: {fileID: -1567122069935691074, guid: 713219d18e2f8c440b4e4435211afb23, type: 2} + m_fontSharedMaterials: [] + m_fontMaterial: {fileID: 0} + m_fontMaterials: [] + m_fontColor32: + serializedVersion: 2 + rgba: 4281479730 + m_fontColor: {r: 0.19607843, g: 0.19607843, b: 0.19607843, a: 1} + m_enableVertexGradient: 0 + m_colorMode: 3 + m_fontColorGradient: + topLeft: {r: 1, g: 1, b: 1, a: 1} + topRight: {r: 1, g: 1, b: 1, a: 1} + bottomLeft: {r: 1, g: 1, b: 1, a: 1} + bottomRight: {r: 1, g: 1, b: 1, a: 1} + m_fontColorGradientPreset: {fileID: 0} + m_spriteAsset: {fileID: 0} + m_tintAllSprites: 0 + m_StyleSheet: {fileID: 0} + m_TextStyleHashCode: -1183493901 + m_overrideHtmlColors: 0 + m_faceColor: + serializedVersion: 2 + rgba: 4294967295 + m_fontSize: 14 + m_fontSizeBase: 14 + m_fontWeight: 400 + m_enableAutoSizing: 0 + m_fontSizeMin: 18 + m_fontSizeMax: 72 + m_fontStyle: 0 + m_HorizontalAlignment: 2 + m_VerticalAlignment: 512 + m_textAlignment: 65535 + m_characterSpacing: 0 + m_wordSpacing: 0 + m_lineSpacing: 0 + m_lineSpacingMax: 0 + m_paragraphSpacing: 0 + m_charWidthMaxAdj: 0 + m_enableWordWrapping: 0 + m_wordWrappingRatios: 0.4 + m_overflowMode: 0 + m_linkedTextComponent: {fileID: 0} + parentLinkedComponent: {fileID: 0} + m_enableKerning: 1 + m_enableExtraPadding: 1 + checkPaddingRequired: 0 + m_isRichText: 1 + m_parseCtrlCharacters: 1 + m_isOrthographic: 1 + m_isCullingEnabled: 0 + m_horizontalMapping: 0 + m_verticalMapping: 0 + m_uvLineOffset: 0 + m_geometrySortingOrder: 0 + m_IsTextObjectScaleStatic: 0 + m_VertexBufferAutoSizeReduction: 0 + m_useMaxVisibleDescender: 1 + m_pageToDisplay: 1 + m_margin: {x: 0, y: 0, z: 0, w: 0} + m_isUsingLegacyAnimationComponent: 0 + m_isVolumetricText: 0 + m_hasFontAssetChanged: 0 + m_baseMaterial: {fileID: 0} + m_maskOffset: {x: 0, y: 0, z: 0, w: 0} +--- !u!114 &8444637016276988767 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 8444637016276988761} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 306cc8c2b49d7114eaa3623786fc2126, type: 3} + m_Name: + m_EditorClassIdentifier: + m_IgnoreLayout: 1 + m_MinWidth: -1 + m_MinHeight: -1 + m_PreferredWidth: -1 + m_PreferredHeight: -1 + m_FlexibleWidth: -1 + m_FlexibleHeight: -1 + m_LayoutPriority: 1 +--- !u!1 &8444637016306948232 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 8444637016306948239} + - component: {fileID: 8444637016306948238} + m_Layer: 5 + m_Name: Text Area + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &8444637016306948239 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 8444637016306948232} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: + - {fileID: 8444637016276988760} + - {fileID: 8444637015474898735} + m_Father: {fileID: 8444637016535975175} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: -0.5} + m_SizeDelta: {x: -20, y: -13} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!114 &8444637016306948238 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 8444637016306948232} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 3312d7739989d2b4e91e6319e9a96d76, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Padding: {x: -8, y: -5, z: -8, w: -5} + m_Softness: {x: 0, y: 0} +--- !u!1 &8444637016535975168 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 8444637016535975175} + - component: {fileID: 8444637016535975172} + - component: {fileID: 8444637016535975173} + - component: {fileID: 8444637016535975174} + m_Layer: 5 + m_Name: inputx + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &8444637016535975175 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 8444637016535975168} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: + - {fileID: 8444637016306948239} + m_Father: {fileID: 8444637014727969524} + m_RootOrder: 3 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 0, y: 0} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 110, y: 35} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &8444637016535975172 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 8444637016535975168} + m_CullTransparentMesh: 1 +--- !u!114 &8444637016535975173 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 8444637016535975168} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_Sprite: {fileID: 21300000, guid: c9036691e9378664ea18dc8a90cfa180, type: 3} + m_Type: 0 + m_PreserveAspect: 0 + m_FillCenter: 1 + m_FillMethod: 4 + m_FillAmount: 1 + m_FillClockwise: 1 + m_FillOrigin: 0 + m_UseSpriteMesh: 0 + m_PixelsPerUnitMultiplier: 1 +--- !u!114 &8444637016535975174 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 8444637016535975168} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 2da0c512f12947e489f739169773d7ca, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Navigation: + m_Mode: 3 + m_WrapAround: 0 + m_SelectOnUp: {fileID: 0} + m_SelectOnDown: {fileID: 0} + m_SelectOnLeft: {fileID: 0} + m_SelectOnRight: {fileID: 0} + m_Transition: 1 + m_Colors: + m_NormalColor: {r: 1, g: 1, b: 1, a: 1} + m_HighlightedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} + m_PressedColor: {r: 0.4268423, g: 0.66566586, b: 0.8301887, a: 1} + m_SelectedColor: {r: 0.42745098, g: 0.6666667, b: 0.83137256, a: 1} + m_DisabledColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 0.5019608} + m_ColorMultiplier: 1 + m_FadeDuration: 0.1 + m_SpriteState: + m_HighlightedSprite: {fileID: 0} + m_PressedSprite: {fileID: 0} + m_SelectedSprite: {fileID: 0} + m_DisabledSprite: {fileID: 0} + m_AnimationTriggers: + m_NormalTrigger: Normal + m_HighlightedTrigger: Highlighted + m_PressedTrigger: Pressed + m_SelectedTrigger: Selected + m_DisabledTrigger: Disabled + m_Interactable: 1 + m_TargetGraphic: {fileID: 8444637016535975173} + m_TextViewport: {fileID: 8444637016306948239} + m_TextComponent: {fileID: 8444637015474898734} + m_Placeholder: {fileID: 8444637016276988766} + m_VerticalScrollbar: {fileID: 0} + m_VerticalScrollbarEventHandler: {fileID: 0} + m_LayoutGroup: {fileID: 0} + m_ScrollSensitivity: 1 + m_ContentType: 3 + m_InputType: 0 + m_AsteriskChar: 42 + m_KeyboardType: 2 + m_LineType: 0 + m_HideMobileInput: 0 + m_HideSoftKeyboard: 0 + m_CharacterValidation: 3 + m_RegexValue: + m_GlobalPointSize: 14 + m_CharacterLimit: 0 + m_OnEndEdit: + m_PersistentCalls: + m_Calls: [] + m_OnSubmit: + m_PersistentCalls: + m_Calls: [] + m_OnSelect: + m_PersistentCalls: + m_Calls: [] + m_OnDeselect: + m_PersistentCalls: + m_Calls: [] + m_OnTextSelection: + m_PersistentCalls: + m_Calls: [] + m_OnEndTextSelection: + m_PersistentCalls: + m_Calls: [] + m_OnValueChanged: + m_PersistentCalls: + m_Calls: [] + m_OnTouchScreenKeyboardStatusChanged: + m_PersistentCalls: + m_Calls: [] + m_CaretColor: {r: 0.19607843, g: 0.19607843, b: 0.19607843, a: 1} + m_CustomCaretColor: 0 + m_SelectionColor: {r: 0.65882355, g: 0.80784315, b: 1, a: 0.7529412} + m_Text: 0 + m_CaretBlinkRate: 0.85 + m_CaretWidth: 1 + m_ReadOnly: 0 + m_RichText: 1 + m_GlobalFontAsset: {fileID: 11400000, guid: 8f586378b4e144a9851e7b34d9b748ee, type: 2} + m_OnFocusSelectAll: 1 + m_ResetOnDeActivation: 1 + m_RestoreOriginalTextOnEscape: 1 + m_isRichTextEditingAllowed: 0 + m_LineLimit: 0 + m_InputValidator: {fileID: 0} +--- !u!1 &8660828241241692425 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 5520907964103984873} + - component: {fileID: 8406094315771953901} + - component: {fileID: 4929563806023776477} + - component: {fileID: 382614920130264398} + m_Layer: 5 + m_Name: addbutton + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &5520907964103984873 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 8660828241241692425} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: [] + m_Father: {fileID: 8444637014727969524} + m_RootOrder: 4 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 0, y: 0} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 35, y: 35} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &8406094315771953901 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 8660828241241692425} + m_CullTransparentMesh: 1 +--- !u!114 &4929563806023776477 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 8660828241241692425} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_Sprite: {fileID: 21300000, guid: b78b596c931076344af59317a8b1a39d, type: 3} + m_Type: 0 + m_PreserveAspect: 0 + m_FillCenter: 1 + m_FillMethod: 4 + m_FillAmount: 1 + m_FillClockwise: 1 + m_FillOrigin: 0 + m_UseSpriteMesh: 0 + m_PixelsPerUnitMultiplier: 1 +--- !u!114 &382614920130264398 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 8660828241241692425} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 4e29b1a8efbd4b44bb3f3716e73f07ff, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Navigation: + m_Mode: 3 + m_WrapAround: 0 + m_SelectOnUp: {fileID: 0} + m_SelectOnDown: {fileID: 0} + m_SelectOnLeft: {fileID: 0} + m_SelectOnRight: {fileID: 0} + m_Transition: 1 + m_Colors: + m_NormalColor: {r: 1, g: 1, b: 1, a: 1} + m_HighlightedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} + m_PressedColor: {r: 0.40650588, g: 0.7546515, b: 0.990566, a: 1} + m_SelectedColor: {r: 1, g: 1, b: 1, a: 1} + m_DisabledColor: {r: 1, g: 1, b: 1, a: 1} + m_ColorMultiplier: 1 + m_FadeDuration: 0.1 + m_SpriteState: + m_HighlightedSprite: {fileID: 0} + m_PressedSprite: {fileID: 0} + m_SelectedSprite: {fileID: 0} + m_DisabledSprite: {fileID: 0} + m_AnimationTriggers: + m_NormalTrigger: Normal + m_HighlightedTrigger: Highlighted + m_PressedTrigger: Pressed + m_SelectedTrigger: Selected + m_DisabledTrigger: Disabled + m_Interactable: 1 + m_TargetGraphic: {fileID: 4929563806023776477} + m_OnClick: + m_PersistentCalls: + m_Calls: [] diff --git a/Resources/Prefab/ConfigUIItem/ConfigDropDown.prefab b/Resources/Prefab/ConfigUIItem/ConfigDropDown.prefab new file mode 100644 index 0000000..44efad6 --- /dev/null +++ b/Resources/Prefab/ConfigUIItem/ConfigDropDown.prefab @@ -0,0 +1,1844 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!1 &155970829008295623 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 155970829008295616} + - component: {fileID: 155970829008295619} + - component: {fileID: 155970829008295618} + - component: {fileID: 155970829008295617} + m_Layer: 5 + m_Name: dropdown + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &155970829008295616 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 155970829008295623} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: + - {fileID: 155970829308717082} + - {fileID: 155970829572609865} + - {fileID: 155970830348333640} + m_Father: {fileID: 588522920000014489} + m_RootOrder: 2 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 0, y: 0} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 180, y: 30} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &155970829008295619 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 155970829008295623} + m_CullTransparentMesh: 1 +--- !u!114 &155970829008295618 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 155970829008295623} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_Sprite: {fileID: 10905, guid: 0000000000000000f000000000000000, type: 0} + m_Type: 1 + m_PreserveAspect: 0 + m_FillCenter: 1 + m_FillMethod: 4 + m_FillAmount: 1 + m_FillClockwise: 1 + m_FillOrigin: 0 + m_UseSpriteMesh: 0 + m_PixelsPerUnitMultiplier: 1 +--- !u!114 &155970829008295617 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 155970829008295623} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 7b743370ac3e4ec2a1668f5455a8ef8a, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Navigation: + m_Mode: 3 + m_WrapAround: 0 + m_SelectOnUp: {fileID: 0} + m_SelectOnDown: {fileID: 0} + m_SelectOnLeft: {fileID: 0} + m_SelectOnRight: {fileID: 0} + m_Transition: 1 + m_Colors: + m_NormalColor: {r: 1, g: 1, b: 1, a: 1} + m_HighlightedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} + m_PressedColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 1} + m_SelectedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} + m_DisabledColor: {r: 1, g: 1, b: 1, a: 0.5019608} + m_ColorMultiplier: 1 + m_FadeDuration: 0.1 + m_SpriteState: + m_HighlightedSprite: {fileID: 0} + m_PressedSprite: {fileID: 0} + m_SelectedSprite: {fileID: 0} + m_DisabledSprite: {fileID: 0} + m_AnimationTriggers: + m_NormalTrigger: Normal + m_HighlightedTrigger: Highlighted + m_PressedTrigger: Pressed + m_SelectedTrigger: Selected + m_DisabledTrigger: Disabled + m_Interactable: 1 + m_TargetGraphic: {fileID: 155970829008295618} + m_Template: {fileID: 155970830348333640} + m_CaptionText: {fileID: 155970829308717083} + m_CaptionImage: {fileID: 0} + m_Placeholder: {fileID: 0} + m_ItemText: {fileID: 155970829386797032} + m_ItemImage: {fileID: 0} + m_Value: 0 + m_Options: + m_Options: + - m_Text: Invalid Option + m_Image: {fileID: 0} + m_OnValueChanged: + m_PersistentCalls: + m_Calls: [] + m_AlphaFadeSpeed: 0.15 +--- !u!1 &155970829115881274 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 155970829115881275} + - component: {fileID: 155970829115881252} + m_Layer: 5 + m_Name: Item + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &155970829115881275 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 155970829115881274} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: + - {fileID: 155970829227588949} + - {fileID: 155970829904291779} + - {fileID: 155970829386797039} + m_Father: {fileID: 155970829919235375} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0.5} + m_AnchorMax: {x: 1, y: 0.5} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 0, y: 20} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!114 &155970829115881252 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 155970829115881274} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 9085046f02f69544eb97fd06b6048fe2, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Navigation: + m_Mode: 3 + m_WrapAround: 0 + m_SelectOnUp: {fileID: 0} + m_SelectOnDown: {fileID: 0} + m_SelectOnLeft: {fileID: 0} + m_SelectOnRight: {fileID: 0} + m_Transition: 1 + m_Colors: + m_NormalColor: {r: 1, g: 1, b: 1, a: 1} + m_HighlightedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} + m_PressedColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 1} + m_SelectedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} + m_DisabledColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 0.5019608} + m_ColorMultiplier: 1 + m_FadeDuration: 0.1 + m_SpriteState: + m_HighlightedSprite: {fileID: 0} + m_PressedSprite: {fileID: 0} + m_SelectedSprite: {fileID: 0} + m_DisabledSprite: {fileID: 0} + m_AnimationTriggers: + m_NormalTrigger: Normal + m_HighlightedTrigger: Highlighted + m_PressedTrigger: Pressed + m_SelectedTrigger: Selected + m_DisabledTrigger: Disabled + m_Interactable: 1 + m_TargetGraphic: {fileID: 155970829227588950} + toggleTransition: 1 + graphic: {fileID: 155970829904291788} + m_Group: {fileID: 0} + onValueChanged: + m_PersistentCalls: + m_Calls: [] + m_IsOn: 1 +--- !u!1 &155970829227588948 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 155970829227588949} + - component: {fileID: 155970829227588951} + - component: {fileID: 155970829227588950} + m_Layer: 5 + m_Name: Item Background + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &155970829227588949 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 155970829227588948} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: [] + m_Father: {fileID: 155970829115881275} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 0, y: 0} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &155970829227588951 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 155970829227588948} + m_CullTransparentMesh: 1 +--- !u!114 &155970829227588950 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 155970829227588948} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_Sprite: {fileID: 0} + m_Type: 0 + m_PreserveAspect: 0 + m_FillCenter: 1 + m_FillMethod: 4 + m_FillAmount: 1 + m_FillClockwise: 1 + m_FillOrigin: 0 + m_UseSpriteMesh: 0 + m_PixelsPerUnitMultiplier: 1 +--- !u!1 &155970829308717081 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 155970829308717082} + - component: {fileID: 155970829308717060} + - component: {fileID: 155970829308717083} + m_Layer: 5 + m_Name: Label + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &155970829308717082 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 155970829308717081} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: [] + m_Father: {fileID: 155970829008295616} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: -7.5, y: -0.5} + m_SizeDelta: {x: -35, y: -13} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &155970829308717060 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 155970829308717081} + m_CullTransparentMesh: 1 +--- !u!114 &155970829308717083 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 155970829308717081} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: f4688fdb7df04437aeb418b961361dc5, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_text: Invalid Option + m_isRightToLeft: 0 + m_fontAsset: {fileID: 11400000, guid: 713219d18e2f8c440b4e4435211afb23, type: 2} + m_sharedMaterial: {fileID: -1567122069935691074, guid: 713219d18e2f8c440b4e4435211afb23, type: 2} + m_fontSharedMaterials: [] + m_fontMaterial: {fileID: 0} + m_fontMaterials: [] + m_fontColor32: + serializedVersion: 2 + rgba: 4281479730 + m_fontColor: {r: 0.19607843, g: 0.19607843, b: 0.19607843, a: 1} + m_enableVertexGradient: 0 + m_colorMode: 3 + m_fontColorGradient: + topLeft: {r: 1, g: 1, b: 1, a: 1} + topRight: {r: 1, g: 1, b: 1, a: 1} + bottomLeft: {r: 1, g: 1, b: 1, a: 1} + bottomRight: {r: 1, g: 1, b: 1, a: 1} + m_fontColorGradientPreset: {fileID: 0} + m_spriteAsset: {fileID: 0} + m_tintAllSprites: 0 + m_StyleSheet: {fileID: 0} + m_TextStyleHashCode: -1183493901 + m_overrideHtmlColors: 0 + m_faceColor: + serializedVersion: 2 + rgba: 4294967295 + m_fontSize: 16 + m_fontSizeBase: 16 + m_fontWeight: 400 + m_enableAutoSizing: 0 + m_fontSizeMin: 18 + m_fontSizeMax: 72 + m_fontStyle: 0 + m_HorizontalAlignment: 1 + m_VerticalAlignment: 512 + m_textAlignment: 65535 + m_characterSpacing: 0 + m_wordSpacing: 0 + m_lineSpacing: 0 + m_lineSpacingMax: 0 + m_paragraphSpacing: 0 + m_charWidthMaxAdj: 0 + m_enableWordWrapping: 1 + m_wordWrappingRatios: 0.4 + m_overflowMode: 0 + m_linkedTextComponent: {fileID: 0} + parentLinkedComponent: {fileID: 0} + m_enableKerning: 1 + m_enableExtraPadding: 0 + checkPaddingRequired: 0 + m_isRichText: 1 + m_parseCtrlCharacters: 1 + m_isOrthographic: 1 + m_isCullingEnabled: 0 + m_horizontalMapping: 0 + m_verticalMapping: 0 + m_uvLineOffset: 0 + m_geometrySortingOrder: 0 + m_IsTextObjectScaleStatic: 0 + m_VertexBufferAutoSizeReduction: 0 + m_useMaxVisibleDescender: 1 + m_pageToDisplay: 1 + m_margin: {x: 0, y: 0, z: 0, w: 0} + m_isUsingLegacyAnimationComponent: 0 + m_isVolumetricText: 0 + m_hasFontAssetChanged: 0 + m_baseMaterial: {fileID: 0} + m_maskOffset: {x: 0, y: 0, z: 0, w: 0} +--- !u!1 &155970829386797038 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 155970829386797039} + - component: {fileID: 155970829386797033} + - component: {fileID: 155970829386797032} + m_Layer: 5 + m_Name: Item Label + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &155970829386797039 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 155970829386797038} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: [] + m_Father: {fileID: 155970829115881275} + m_RootOrder: 2 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 5, y: -0.5} + m_SizeDelta: {x: -30, y: -3} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &155970829386797033 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 155970829386797038} + m_CullTransparentMesh: 1 +--- !u!114 &155970829386797032 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 155970829386797038} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: f4688fdb7df04437aeb418b961361dc5, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_text: Option A + m_isRightToLeft: 0 + m_fontAsset: {fileID: 11400000, guid: 713219d18e2f8c440b4e4435211afb23, type: 2} + m_sharedMaterial: {fileID: -1567122069935691074, guid: 713219d18e2f8c440b4e4435211afb23, type: 2} + m_fontSharedMaterials: [] + m_fontMaterial: {fileID: 0} + m_fontMaterials: [] + m_fontColor32: + serializedVersion: 2 + rgba: 4294967295 + m_fontColor: {r: 0.19607843, g: 0.19607843, b: 0.19607843, a: 1} + m_enableVertexGradient: 0 + m_colorMode: 3 + m_fontColorGradient: + topLeft: {r: 1, g: 1, b: 1, a: 1} + topRight: {r: 1, g: 1, b: 1, a: 1} + bottomLeft: {r: 1, g: 1, b: 1, a: 1} + bottomRight: {r: 1, g: 1, b: 1, a: 1} + m_fontColorGradientPreset: {fileID: 0} + m_spriteAsset: {fileID: 0} + m_tintAllSprites: 0 + m_StyleSheet: {fileID: 0} + m_TextStyleHashCode: 0 + m_overrideHtmlColors: 0 + m_faceColor: + serializedVersion: 2 + rgba: 4294967295 + m_fontSize: 14 + m_fontSizeBase: 14 + m_fontWeight: 400 + m_enableAutoSizing: 0 + m_fontSizeMin: 18 + m_fontSizeMax: 72 + m_fontStyle: 0 + m_HorizontalAlignment: 1 + m_VerticalAlignment: 512 + m_textAlignment: 65535 + m_characterSpacing: 0 + m_wordSpacing: 0 + m_lineSpacing: 0 + m_lineSpacingMax: 0 + m_paragraphSpacing: 0 + m_charWidthMaxAdj: 0 + m_enableWordWrapping: 1 + m_wordWrappingRatios: 0.4 + m_overflowMode: 0 + m_linkedTextComponent: {fileID: 0} + parentLinkedComponent: {fileID: 0} + m_enableKerning: 1 + m_enableExtraPadding: 0 + checkPaddingRequired: 0 + m_isRichText: 1 + m_parseCtrlCharacters: 1 + m_isOrthographic: 1 + m_isCullingEnabled: 0 + m_horizontalMapping: 0 + m_verticalMapping: 0 + m_uvLineOffset: 0 + m_geometrySortingOrder: 0 + m_IsTextObjectScaleStatic: 0 + m_VertexBufferAutoSizeReduction: 0 + m_useMaxVisibleDescender: 1 + m_pageToDisplay: 1 + m_margin: {x: 0, y: 0, z: 0, w: 0} + m_isUsingLegacyAnimationComponent: 0 + m_isVolumetricText: 0 + m_hasFontAssetChanged: 0 + m_baseMaterial: {fileID: 0} + m_maskOffset: {x: 0, y: 0, z: 0, w: 0} +--- !u!1 &155970829404833466 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 155970829404833467} + - component: {fileID: 155970829404833445} + - component: {fileID: 155970829404833444} + m_Layer: 5 + m_Name: Handle + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &155970829404833467 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 155970829404833466} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: [] + m_Father: {fileID: 155970829987470544} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 0.2} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 20, y: 20} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &155970829404833445 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 155970829404833466} + m_CullTransparentMesh: 1 +--- !u!114 &155970829404833444 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 155970829404833466} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_Sprite: {fileID: 10905, guid: 0000000000000000f000000000000000, type: 0} + m_Type: 1 + m_PreserveAspect: 0 + m_FillCenter: 1 + m_FillMethod: 4 + m_FillAmount: 1 + m_FillClockwise: 1 + m_FillOrigin: 0 + m_UseSpriteMesh: 0 + m_PixelsPerUnitMultiplier: 1 +--- !u!1 &155970829572609864 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 155970829572609865} + - component: {fileID: 155970829572609867} + - component: {fileID: 155970829572609866} + m_Layer: 5 + m_Name: Arrow + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &155970829572609865 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 155970829572609864} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: [] + m_Father: {fileID: 155970829008295616} + m_RootOrder: 1 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 1, y: 0.5} + m_AnchorMax: {x: 1, y: 0.5} + m_AnchoredPosition: {x: -15, y: 0} + m_SizeDelta: {x: 20, y: 20} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &155970829572609867 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 155970829572609864} + m_CullTransparentMesh: 1 +--- !u!114 &155970829572609866 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 155970829572609864} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_Sprite: {fileID: 10915, guid: 0000000000000000f000000000000000, type: 0} + m_Type: 0 + m_PreserveAspect: 0 + m_FillCenter: 1 + m_FillMethod: 4 + m_FillAmount: 1 + m_FillClockwise: 1 + m_FillOrigin: 0 + m_UseSpriteMesh: 0 + m_PixelsPerUnitMultiplier: 1 +--- !u!1 &155970829904291778 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 155970829904291779} + - component: {fileID: 155970829904291789} + - component: {fileID: 155970829904291788} + m_Layer: 5 + m_Name: Item Checkmark + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &155970829904291779 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 155970829904291778} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: [] + m_Father: {fileID: 155970829115881275} + m_RootOrder: 1 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0.5} + m_AnchorMax: {x: 0, y: 0.5} + m_AnchoredPosition: {x: 10, y: 0} + m_SizeDelta: {x: 20, y: 20} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &155970829904291789 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 155970829904291778} + m_CullTransparentMesh: 1 +--- !u!114 &155970829904291788 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 155970829904291778} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_Sprite: {fileID: 10901, guid: 0000000000000000f000000000000000, type: 0} + m_Type: 0 + m_PreserveAspect: 0 + m_FillCenter: 1 + m_FillMethod: 4 + m_FillAmount: 1 + m_FillClockwise: 1 + m_FillOrigin: 0 + m_UseSpriteMesh: 0 + m_PixelsPerUnitMultiplier: 1 +--- !u!1 &155970829919235374 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 155970829919235375} + m_Layer: 5 + m_Name: Content + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &155970829919235375 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 155970829919235374} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: + - {fileID: 155970829115881275} + m_Father: {fileID: 155970830583955612} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 1} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 0, y: 28} + m_Pivot: {x: 0.5, y: 1} +--- !u!1 &155970829987470551 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 155970829987470544} + m_Layer: 5 + m_Name: Sliding Area + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &155970829987470544 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 155970829987470551} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: + - {fileID: 155970829404833467} + m_Father: {fileID: 155970830261558849} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: -20, y: -20} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!1 &155970830261558848 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 155970830261558849} + - component: {fileID: 155970830261558860} + - component: {fileID: 155970830261558851} + - component: {fileID: 155970830261558850} + m_Layer: 5 + m_Name: Scrollbar + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &155970830261558849 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 155970830261558848} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: + - {fileID: 155970829987470544} + m_Father: {fileID: 155970830348333640} + m_RootOrder: 1 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 1, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 20, y: 0} + m_Pivot: {x: 1, y: 1} +--- !u!222 &155970830261558860 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 155970830261558848} + m_CullTransparentMesh: 1 +--- !u!114 &155970830261558851 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 155970830261558848} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_Sprite: {fileID: 10907, guid: 0000000000000000f000000000000000, type: 0} + m_Type: 1 + m_PreserveAspect: 0 + m_FillCenter: 1 + m_FillMethod: 4 + m_FillAmount: 1 + m_FillClockwise: 1 + m_FillOrigin: 0 + m_UseSpriteMesh: 0 + m_PixelsPerUnitMultiplier: 1 +--- !u!114 &155970830261558850 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 155970830261558848} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 2a4db7a114972834c8e4117be1d82ba3, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Navigation: + m_Mode: 3 + m_WrapAround: 0 + m_SelectOnUp: {fileID: 0} + m_SelectOnDown: {fileID: 0} + m_SelectOnLeft: {fileID: 0} + m_SelectOnRight: {fileID: 0} + m_Transition: 1 + m_Colors: + m_NormalColor: {r: 1, g: 1, b: 1, a: 1} + m_HighlightedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} + m_PressedColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 1} + m_SelectedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} + m_DisabledColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 0.5019608} + m_ColorMultiplier: 1 + m_FadeDuration: 0.1 + m_SpriteState: + m_HighlightedSprite: {fileID: 0} + m_PressedSprite: {fileID: 0} + m_SelectedSprite: {fileID: 0} + m_DisabledSprite: {fileID: 0} + m_AnimationTriggers: + m_NormalTrigger: Normal + m_HighlightedTrigger: Highlighted + m_PressedTrigger: Pressed + m_SelectedTrigger: Selected + m_DisabledTrigger: Disabled + m_Interactable: 1 + m_TargetGraphic: {fileID: 155970829404833444} + m_HandleRect: {fileID: 155970829404833467} + m_Direction: 2 + m_Value: 0 + m_Size: 0.2 + m_NumberOfSteps: 0 + m_OnValueChanged: + m_PersistentCalls: + m_Calls: [] +--- !u!1 &155970830348333647 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 155970830348333640} + - component: {fileID: 155970830348333643} + - component: {fileID: 155970830348333642} + - component: {fileID: 155970830348333641} + m_Layer: 5 + m_Name: Template + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 0 +--- !u!224 &155970830348333640 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 155970830348333647} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: + - {fileID: 155970830583955612} + - {fileID: 155970830261558849} + m_Father: {fileID: 155970829008295616} + m_RootOrder: 2 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 0} + m_AnchoredPosition: {x: 0, y: 2} + m_SizeDelta: {x: 0, y: 150} + m_Pivot: {x: 0.5, y: 1} +--- !u!222 &155970830348333643 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 155970830348333647} + m_CullTransparentMesh: 1 +--- !u!114 &155970830348333642 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 155970830348333647} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_Sprite: {fileID: 10905, guid: 0000000000000000f000000000000000, type: 0} + m_Type: 1 + m_PreserveAspect: 0 + m_FillCenter: 1 + m_FillMethod: 4 + m_FillAmount: 1 + m_FillClockwise: 1 + m_FillOrigin: 0 + m_UseSpriteMesh: 0 + m_PixelsPerUnitMultiplier: 1 +--- !u!114 &155970830348333641 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 155970830348333647} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 1aa08ab6e0800fa44ae55d278d1423e3, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Content: {fileID: 155970829919235375} + m_Horizontal: 0 + m_Vertical: 1 + m_MovementType: 2 + m_Elasticity: 0.1 + m_Inertia: 1 + m_DecelerationRate: 0.135 + m_ScrollSensitivity: 1 + m_Viewport: {fileID: 155970830583955612} + m_HorizontalScrollbar: {fileID: 0} + m_VerticalScrollbar: {fileID: 155970830261558850} + m_HorizontalScrollbarVisibility: 0 + m_VerticalScrollbarVisibility: 2 + m_HorizontalScrollbarSpacing: 0 + m_VerticalScrollbarSpacing: -3 + m_OnValueChanged: + m_PersistentCalls: + m_Calls: [] +--- !u!1 &155970830583955603 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 155970830583955612} + - component: {fileID: 155970830583955615} + - component: {fileID: 155970830583955614} + - component: {fileID: 155970830583955613} + m_Layer: 5 + m_Name: Viewport + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &155970830583955612 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 155970830583955603} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: + - {fileID: 155970829919235375} + m_Father: {fileID: 155970830348333640} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: -18, y: 0} + m_Pivot: {x: 0, y: 1} +--- !u!114 &155970830583955615 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 155970830583955603} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 31a19414c41e5ae4aae2af33fee712f6, type: 3} + m_Name: + m_EditorClassIdentifier: + m_ShowMaskGraphic: 0 +--- !u!222 &155970830583955614 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 155970830583955603} + m_CullTransparentMesh: 1 +--- !u!114 &155970830583955613 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 155970830583955603} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_Sprite: {fileID: 10917, guid: 0000000000000000f000000000000000, type: 0} + m_Type: 1 + m_PreserveAspect: 0 + m_FillCenter: 1 + m_FillMethod: 4 + m_FillAmount: 1 + m_FillClockwise: 1 + m_FillOrigin: 0 + m_UseSpriteMesh: 0 + m_PixelsPerUnitMultiplier: 1 +--- !u!1 &2509847893430926344 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 2509847893430926347} + - component: {fileID: 2509847893430926346} + m_Layer: 5 + m_Name: Toggle + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &2509847893430926347 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2509847893430926344} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: + - {fileID: 2509847894679763547} + - {fileID: 2509847895524543505} + m_Father: {fileID: 2509847894958671959} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0.5} + m_AnchorMax: {x: 0, y: 0.5} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 16, y: 16} + m_Pivot: {x: 0, y: 0.5} +--- !u!114 &2509847893430926346 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2509847893430926344} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 9085046f02f69544eb97fd06b6048fe2, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Navigation: + m_Mode: 3 + m_WrapAround: 0 + m_SelectOnUp: {fileID: 0} + m_SelectOnDown: {fileID: 0} + m_SelectOnLeft: {fileID: 0} + m_SelectOnRight: {fileID: 0} + m_Transition: 1 + m_Colors: + m_NormalColor: {r: 1, g: 1, b: 1, a: 1} + m_HighlightedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} + m_PressedColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 1} + m_SelectedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} + m_DisabledColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 0.5019608} + m_ColorMultiplier: 1 + m_FadeDuration: 0.1 + m_SpriteState: + m_HighlightedSprite: {fileID: 0} + m_PressedSprite: {fileID: 0} + m_SelectedSprite: {fileID: 0} + m_DisabledSprite: {fileID: 0} + m_AnimationTriggers: + m_NormalTrigger: Normal + m_HighlightedTrigger: Highlighted + m_PressedTrigger: Pressed + m_SelectedTrigger: Selected + m_DisabledTrigger: Disabled + m_Interactable: 1 + m_TargetGraphic: {fileID: 2509847894679763546} + toggleTransition: 1 + graphic: {fileID: 2509847895524543504} + m_Group: {fileID: 0} + onValueChanged: + m_PersistentCalls: + m_Calls: [] + m_IsOn: 0 +--- !u!1 &2509847894679763544 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 2509847894679763547} + - component: {fileID: 2509847894679763549} + - component: {fileID: 2509847894679763546} + m_Layer: 5 + m_Name: Background + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &2509847894679763547 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2509847894679763544} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: [] + m_Father: {fileID: 2509847893430926347} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0.03426361, y: 0.00049591064} + m_SizeDelta: {x: 0.065603256, y: 0.00012207031} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &2509847894679763549 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2509847894679763544} + m_CullTransparentMesh: 1 +--- !u!114 &2509847894679763546 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2509847894679763544} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_Sprite: {fileID: 21300000, guid: 56a95a2d9d13e774093a51bcbebb8e7f, type: 3} + m_Type: 0 + m_PreserveAspect: 0 + m_FillCenter: 1 + m_FillMethod: 4 + m_FillAmount: 1 + m_FillClockwise: 1 + m_FillOrigin: 0 + m_UseSpriteMesh: 0 + m_PixelsPerUnitMultiplier: 1 +--- !u!1 &2509847894958671956 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 2509847894958671959} + m_Layer: 5 + m_Name: toggle + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &2509847894958671959 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2509847894958671956} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: + - {fileID: 2509847893430926347} + m_Father: {fileID: 588522920000014489} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 0, y: 0} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 22, y: 40} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!1 &2509847895524543518 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 2509847895524543505} + - component: {fileID: 2509847895524543507} + - component: {fileID: 2509847895524543504} + m_Layer: 5 + m_Name: Checkmark + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &2509847895524543505 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2509847895524543518} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: [] + m_Father: {fileID: 2509847893430926347} + m_RootOrder: 1 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: -0.00000014901161, y: 0.00000013579847} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &2509847895524543507 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2509847895524543518} + m_CullTransparentMesh: 1 +--- !u!114 &2509847895524543504 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2509847895524543518} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_Sprite: {fileID: 21300000, guid: 1f2a868175c8a8a47a887eea9056fe28, type: 3} + m_Type: 0 + m_PreserveAspect: 0 + m_FillCenter: 1 + m_FillMethod: 4 + m_FillAmount: 1 + m_FillClockwise: 1 + m_FillOrigin: 0 + m_UseSpriteMesh: 0 + m_PixelsPerUnitMultiplier: 1 +--- !u!1 &5269156459145568997 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 1183928383057699821} + - component: {fileID: 4643097127400197726} + - component: {fileID: 6420131218458215638} + m_Layer: 5 + m_Name: help + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &1183928383057699821 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 5269156459145568997} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: [] + m_Father: {fileID: 8755943251677910253} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 1} + m_AnchorMax: {x: 0, y: 1} + m_AnchoredPosition: {x: 0, y: -35} + m_SizeDelta: {x: 300, y: 50} + m_Pivot: {x: 0, y: 1} +--- !u!222 &4643097127400197726 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 5269156459145568997} + m_CullTransparentMesh: 1 +--- !u!114 &6420131218458215638 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 5269156459145568997} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: f4688fdb7df04437aeb418b961361dc5, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_text: + m_isRightToLeft: 0 + m_fontAsset: {fileID: 11400000, guid: 3bd21f304e77db54eb98a1f35f6a2680, type: 2} + m_sharedMaterial: {fileID: -3509209986637506031, guid: 3bd21f304e77db54eb98a1f35f6a2680, type: 2} + m_fontSharedMaterials: [] + m_fontMaterial: {fileID: 0} + m_fontMaterials: [] + m_fontColor32: + serializedVersion: 2 + rgba: 4278190335 + m_fontColor: {r: 1, g: 0, b: 0, a: 1} + m_enableVertexGradient: 0 + m_colorMode: 3 + m_fontColorGradient: + topLeft: {r: 1, g: 1, b: 1, a: 1} + topRight: {r: 1, g: 1, b: 1, a: 1} + bottomLeft: {r: 1, g: 1, b: 1, a: 1} + bottomRight: {r: 1, g: 1, b: 1, a: 1} + m_fontColorGradientPreset: {fileID: 0} + m_spriteAsset: {fileID: 0} + m_tintAllSprites: 0 + m_StyleSheet: {fileID: 0} + m_TextStyleHashCode: -1183493901 + m_overrideHtmlColors: 0 + m_faceColor: + serializedVersion: 2 + rgba: 4294967295 + m_fontSize: 14 + m_fontSizeBase: 14 + m_fontWeight: 400 + m_enableAutoSizing: 0 + m_fontSizeMin: 18 + m_fontSizeMax: 72 + m_fontStyle: 0 + m_HorizontalAlignment: 1 + m_VerticalAlignment: 256 + m_textAlignment: 65535 + m_characterSpacing: 0 + m_wordSpacing: 0 + m_lineSpacing: 0 + m_lineSpacingMax: 0 + m_paragraphSpacing: 0 + m_charWidthMaxAdj: 0 + m_enableWordWrapping: 1 + m_wordWrappingRatios: 0.4 + m_overflowMode: 0 + m_linkedTextComponent: {fileID: 0} + parentLinkedComponent: {fileID: 0} + m_enableKerning: 1 + m_enableExtraPadding: 0 + checkPaddingRequired: 0 + m_isRichText: 1 + m_parseCtrlCharacters: 1 + m_isOrthographic: 1 + m_isCullingEnabled: 0 + m_horizontalMapping: 0 + m_verticalMapping: 0 + m_uvLineOffset: 0 + m_geometrySortingOrder: 0 + m_IsTextObjectScaleStatic: 0 + m_VertexBufferAutoSizeReduction: 0 + m_useMaxVisibleDescender: 1 + m_pageToDisplay: 1 + m_margin: {x: 0, y: 0, z: 0, w: 0} + m_isUsingLegacyAnimationComponent: 0 + m_isVolumetricText: 0 + m_hasFontAssetChanged: 0 + m_baseMaterial: {fileID: 0} + m_maskOffset: {x: 0, y: 0, z: 0, w: 0} +--- !u!1 &6041965097264056608 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 8755943251677910253} + - component: {fileID: 3214207372662412306} + - component: {fileID: 3052551219843262152} + m_Layer: 5 + m_Name: title + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &8755943251677910253 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 6041965097264056608} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: + - {fileID: 1183928383057699821} + m_Father: {fileID: 588522920000014489} + m_RootOrder: 1 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 0, y: 0} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 120, y: 40} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &3214207372662412306 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 6041965097264056608} + m_CullTransparentMesh: 1 +--- !u!114 &3052551219843262152 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 6041965097264056608} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: f4688fdb7df04437aeb418b961361dc5, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_text: + m_isRightToLeft: 0 + m_fontAsset: {fileID: 11400000, guid: 3bd21f304e77db54eb98a1f35f6a2680, type: 2} + m_sharedMaterial: {fileID: -3509209986637506031, guid: 3bd21f304e77db54eb98a1f35f6a2680, type: 2} + m_fontSharedMaterials: [] + m_fontMaterial: {fileID: 0} + m_fontMaterials: [] + m_fontColor32: + serializedVersion: 2 + rgba: 4278190080 + m_fontColor: {r: 0, g: 0, b: 0, a: 1} + m_enableVertexGradient: 0 + m_colorMode: 3 + m_fontColorGradient: + topLeft: {r: 1, g: 1, b: 1, a: 1} + topRight: {r: 1, g: 1, b: 1, a: 1} + bottomLeft: {r: 1, g: 1, b: 1, a: 1} + bottomRight: {r: 1, g: 1, b: 1, a: 1} + m_fontColorGradientPreset: {fileID: 0} + m_spriteAsset: {fileID: 0} + m_tintAllSprites: 0 + m_StyleSheet: {fileID: 0} + m_TextStyleHashCode: -1183493901 + m_overrideHtmlColors: 0 + m_faceColor: + serializedVersion: 2 + rgba: 4294967295 + m_fontSize: 16 + m_fontSizeBase: 16 + m_fontWeight: 400 + m_enableAutoSizing: 0 + m_fontSizeMin: 18 + m_fontSizeMax: 72 + m_fontStyle: 0 + m_HorizontalAlignment: 1 + m_VerticalAlignment: 512 + m_textAlignment: 65535 + m_characterSpacing: 0 + m_wordSpacing: 0 + m_lineSpacing: 0 + m_lineSpacingMax: 0 + m_paragraphSpacing: 0 + m_charWidthMaxAdj: 0 + m_enableWordWrapping: 1 + m_wordWrappingRatios: 0.4 + m_overflowMode: 0 + m_linkedTextComponent: {fileID: 0} + parentLinkedComponent: {fileID: 0} + m_enableKerning: 1 + m_enableExtraPadding: 0 + checkPaddingRequired: 0 + m_isRichText: 1 + m_parseCtrlCharacters: 1 + m_isOrthographic: 1 + m_isCullingEnabled: 0 + m_horizontalMapping: 0 + m_verticalMapping: 0 + m_uvLineOffset: 0 + m_geometrySortingOrder: 0 + m_IsTextObjectScaleStatic: 0 + m_VertexBufferAutoSizeReduction: 0 + m_useMaxVisibleDescender: 1 + m_pageToDisplay: 1 + m_margin: {x: 0, y: -1.5838165, z: 0, w: 0} + m_isUsingLegacyAnimationComponent: 0 + m_isVolumetricText: 0 + m_hasFontAssetChanged: 0 + m_baseMaterial: {fileID: 0} + m_maskOffset: {x: 0, y: 0, z: 0, w: 0} +--- !u!1 &8392574449343776806 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 588522920000014489} + - component: {fileID: 8392574449343776793} + - component: {fileID: 8392574449343776792} + m_Layer: 5 + m_Name: ConfigDropDown + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &588522920000014489 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 8392574449343776806} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: + - {fileID: 2509847894958671959} + - {fileID: 8755943251677910253} + - {fileID: 155970829008295616} + m_Father: {fileID: 0} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0.5, y: 1} + m_AnchorMax: {x: 0.5, y: 1} + m_AnchoredPosition: {x: -100, y: -100} + m_SizeDelta: {x: 320, y: 40} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!114 &8392574449343776793 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 8392574449343776806} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 471d16b38f4449a46b9fcf5b312f65d0, type: 3} + m_Name: + m_EditorClassIdentifier: + configTag: + allowInput: 1 + autoUpdateValue: 1 + allowBlockUpdate: 1 + forceBlockUpdate: 0 + numberFormat: 0.## + titleLabel: {fileID: 3052551219843262152} + titleTextContext: + helpLabel: {fileID: 6420131218458215638} + helpTextContext: + unitLabel: {fileID: 0} + unitTextContext: + autoUpdateValueToggle: {fileID: 2509847893430926346} + autoUpdateValueToggleReversalState: 0 + autoUpdateValueReversalState: 1 + dirtyAutoReset: 0 + targetDropdown: {fileID: 155970829008295617} +--- !u!114 &8392574449343776792 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 8392574449343776806} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 30649d3a9faa99c48a7b1166b86bf2a0, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Padding: + m_Left: 0 + m_Right: 0 + m_Top: 0 + m_Bottom: 0 + m_ChildAlignment: 3 + m_Spacing: 0 + m_ChildForceExpandWidth: 1 + m_ChildForceExpandHeight: 1 + m_ChildControlWidth: 0 + m_ChildControlHeight: 0 + m_ChildScaleWidth: 0 + m_ChildScaleHeight: 0 + m_ReverseArrangement: 0 diff --git a/Resources/Prefab/ConfigUIItem/ConfigInputVec2.prefab b/Resources/Prefab/ConfigUIItem/ConfigInputVec2.prefab new file mode 100644 index 0000000..44010c2 --- /dev/null +++ b/Resources/Prefab/ConfigUIItem/ConfigInputVec2.prefab @@ -0,0 +1,1688 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!1 &4359144213727891030 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 4359144213727891026} + - component: {fileID: 4359144213727891027} + - component: {fileID: 4359144213727891028} + - component: {fileID: 4359144213727891029} + m_Layer: 5 + m_Name: inputx + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &4359144213727891026 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4359144213727891030} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: + - {fileID: 4359144215278372545} + m_Father: {fileID: 4359144215414896298} + m_RootOrder: 2 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 0, y: 0} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 90, y: 35} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &4359144213727891027 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4359144213727891030} + m_CullTransparentMesh: 1 +--- !u!114 &4359144213727891028 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4359144213727891030} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_Sprite: {fileID: 21300000, guid: c9036691e9378664ea18dc8a90cfa180, type: 3} + m_Type: 0 + m_PreserveAspect: 0 + m_FillCenter: 1 + m_FillMethod: 4 + m_FillAmount: 1 + m_FillClockwise: 1 + m_FillOrigin: 0 + m_UseSpriteMesh: 0 + m_PixelsPerUnitMultiplier: 1 +--- !u!114 &4359144213727891029 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4359144213727891030} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 2da0c512f12947e489f739169773d7ca, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Navigation: + m_Mode: 3 + m_WrapAround: 0 + m_SelectOnUp: {fileID: 0} + m_SelectOnDown: {fileID: 0} + m_SelectOnLeft: {fileID: 0} + m_SelectOnRight: {fileID: 0} + m_Transition: 1 + m_Colors: + m_NormalColor: {r: 1, g: 1, b: 1, a: 1} + m_HighlightedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} + m_PressedColor: {r: 0.4268423, g: 0.66566586, b: 0.8301887, a: 1} + m_SelectedColor: {r: 0.42745098, g: 0.6666667, b: 0.83137256, a: 1} + m_DisabledColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 0.5019608} + m_ColorMultiplier: 1 + m_FadeDuration: 0.1 + m_SpriteState: + m_HighlightedSprite: {fileID: 0} + m_PressedSprite: {fileID: 0} + m_SelectedSprite: {fileID: 0} + m_DisabledSprite: {fileID: 0} + m_AnimationTriggers: + m_NormalTrigger: Normal + m_HighlightedTrigger: Highlighted + m_PressedTrigger: Pressed + m_SelectedTrigger: Selected + m_DisabledTrigger: Disabled + m_Interactable: 1 + m_TargetGraphic: {fileID: 4359144213727891028} + m_TextViewport: {fileID: 4359144215278372545} + m_TextComponent: {fileID: 4359144214696212393} + m_Placeholder: {fileID: 4359144213886098625} + m_VerticalScrollbar: {fileID: 0} + m_VerticalScrollbarEventHandler: {fileID: 0} + m_LayoutGroup: {fileID: 0} + m_ScrollSensitivity: 1 + m_ContentType: 0 + m_InputType: 0 + m_AsteriskChar: 42 + m_KeyboardType: 0 + m_LineType: 0 + m_HideMobileInput: 0 + m_HideSoftKeyboard: 0 + m_CharacterValidation: 0 + m_RegexValue: + m_GlobalPointSize: 14 + m_CharacterLimit: 0 + m_OnEndEdit: + m_PersistentCalls: + m_Calls: [] + m_OnSubmit: + m_PersistentCalls: + m_Calls: [] + m_OnSelect: + m_PersistentCalls: + m_Calls: [] + m_OnDeselect: + m_PersistentCalls: + m_Calls: [] + m_OnTextSelection: + m_PersistentCalls: + m_Calls: [] + m_OnEndTextSelection: + m_PersistentCalls: + m_Calls: [] + m_OnValueChanged: + m_PersistentCalls: + m_Calls: [] + m_OnTouchScreenKeyboardStatusChanged: + m_PersistentCalls: + m_Calls: [] + m_CaretColor: {r: 0.19607843, g: 0.19607843, b: 0.19607843, a: 1} + m_CustomCaretColor: 0 + m_SelectionColor: {r: 0.65882355, g: 0.80784315, b: 1, a: 0.7529412} + m_Text: 0 + m_CaretBlinkRate: 0.85 + m_CaretWidth: 1 + m_ReadOnly: 0 + m_RichText: 1 + m_GlobalFontAsset: {fileID: 11400000, guid: 8f586378b4e144a9851e7b34d9b748ee, type: 2} + m_OnFocusSelectAll: 1 + m_ResetOnDeActivation: 1 + m_RestoreOriginalTextOnEscape: 1 + m_isRichTextEditingAllowed: 0 + m_LineLimit: 0 + m_InputValidator: {fileID: 0} +--- !u!1 &4359144213813927357 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 4359144213813927356} + - component: {fileID: 4359144213813927354} + - component: {fileID: 4359144213813927355} + m_Layer: 5 + m_Name: Text + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &4359144213813927356 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4359144213813927357} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: [] + m_Father: {fileID: 4359144214931836700} + m_RootOrder: 1 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 0, y: 0} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &4359144213813927354 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4359144213813927357} + m_CullTransparentMesh: 1 +--- !u!114 &4359144213813927355 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4359144213813927357} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: f4688fdb7df04437aeb418b961361dc5, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_text: "NAN\u200B" + m_isRightToLeft: 0 + m_fontAsset: {fileID: 11400000, guid: 713219d18e2f8c440b4e4435211afb23, type: 2} + m_sharedMaterial: {fileID: -1567122069935691074, guid: 713219d18e2f8c440b4e4435211afb23, type: 2} + m_fontSharedMaterials: [] + m_fontMaterial: {fileID: 0} + m_fontMaterials: [] + m_fontColor32: + serializedVersion: 2 + rgba: 4281479730 + m_fontColor: {r: 0.19607843, g: 0.19607843, b: 0.19607843, a: 1} + m_enableVertexGradient: 0 + m_colorMode: 3 + m_fontColorGradient: + topLeft: {r: 1, g: 1, b: 1, a: 1} + topRight: {r: 1, g: 1, b: 1, a: 1} + bottomLeft: {r: 1, g: 1, b: 1, a: 1} + bottomRight: {r: 1, g: 1, b: 1, a: 1} + m_fontColorGradientPreset: {fileID: 0} + m_spriteAsset: {fileID: 0} + m_tintAllSprites: 0 + m_StyleSheet: {fileID: 0} + m_TextStyleHashCode: -1183493901 + m_overrideHtmlColors: 0 + m_faceColor: + serializedVersion: 2 + rgba: 4294967295 + m_fontSize: 14 + m_fontSizeBase: 14 + m_fontWeight: 400 + m_enableAutoSizing: 0 + m_fontSizeMin: 18 + m_fontSizeMax: 72 + m_fontStyle: 0 + m_HorizontalAlignment: 2 + m_VerticalAlignment: 512 + m_textAlignment: 65535 + m_characterSpacing: 0 + m_wordSpacing: 0 + m_lineSpacing: 0 + m_lineSpacingMax: 0 + m_paragraphSpacing: 0 + m_charWidthMaxAdj: 0 + m_enableWordWrapping: 0 + m_wordWrappingRatios: 0.4 + m_overflowMode: 0 + m_linkedTextComponent: {fileID: 0} + parentLinkedComponent: {fileID: 0} + m_enableKerning: 1 + m_enableExtraPadding: 1 + checkPaddingRequired: 0 + m_isRichText: 1 + m_parseCtrlCharacters: 1 + m_isOrthographic: 1 + m_isCullingEnabled: 0 + m_horizontalMapping: 0 + m_verticalMapping: 0 + m_uvLineOffset: 0 + m_geometrySortingOrder: 0 + m_IsTextObjectScaleStatic: 0 + m_VertexBufferAutoSizeReduction: 0 + m_useMaxVisibleDescender: 1 + m_pageToDisplay: 1 + m_margin: {x: 0, y: 0, z: 0, w: 0} + m_isUsingLegacyAnimationComponent: 0 + m_isVolumetricText: 0 + m_hasFontAssetChanged: 0 + m_baseMaterial: {fileID: 0} + m_maskOffset: {x: 0, y: 0, z: 0, w: 0} +--- !u!1 &4359144213886098626 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 4359144213886098638} + - component: {fileID: 4359144213886098639} + - component: {fileID: 4359144213886098625} + - component: {fileID: 4359144213886098624} + m_Layer: 5 + m_Name: Placeholder + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 0 +--- !u!224 &4359144213886098638 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4359144213886098626} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: [] + m_Father: {fileID: 4359144215278372545} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 0, y: 0} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &4359144213886098639 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4359144213886098626} + m_CullTransparentMesh: 1 +--- !u!114 &4359144213886098625 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4359144213886098626} + m_Enabled: 0 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: f4688fdb7df04437aeb418b961361dc5, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_text: 125 + m_isRightToLeft: 0 + m_fontAsset: {fileID: 11400000, guid: 713219d18e2f8c440b4e4435211afb23, type: 2} + m_sharedMaterial: {fileID: -1567122069935691074, guid: 713219d18e2f8c440b4e4435211afb23, type: 2} + m_fontSharedMaterials: [] + m_fontMaterial: {fileID: 0} + m_fontMaterials: [] + m_fontColor32: + serializedVersion: 2 + rgba: 4281479730 + m_fontColor: {r: 0.19607843, g: 0.19607843, b: 0.19607843, a: 1} + m_enableVertexGradient: 0 + m_colorMode: 3 + m_fontColorGradient: + topLeft: {r: 1, g: 1, b: 1, a: 1} + topRight: {r: 1, g: 1, b: 1, a: 1} + bottomLeft: {r: 1, g: 1, b: 1, a: 1} + bottomRight: {r: 1, g: 1, b: 1, a: 1} + m_fontColorGradientPreset: {fileID: 0} + m_spriteAsset: {fileID: 0} + m_tintAllSprites: 0 + m_StyleSheet: {fileID: 0} + m_TextStyleHashCode: -1183493901 + m_overrideHtmlColors: 0 + m_faceColor: + serializedVersion: 2 + rgba: 4294967295 + m_fontSize: 14 + m_fontSizeBase: 14 + m_fontWeight: 400 + m_enableAutoSizing: 0 + m_fontSizeMin: 18 + m_fontSizeMax: 72 + m_fontStyle: 0 + m_HorizontalAlignment: 2 + m_VerticalAlignment: 512 + m_textAlignment: 65535 + m_characterSpacing: 0 + m_wordSpacing: 0 + m_lineSpacing: 0 + m_lineSpacingMax: 0 + m_paragraphSpacing: 0 + m_charWidthMaxAdj: 0 + m_enableWordWrapping: 0 + m_wordWrappingRatios: 0.4 + m_overflowMode: 0 + m_linkedTextComponent: {fileID: 0} + parentLinkedComponent: {fileID: 0} + m_enableKerning: 1 + m_enableExtraPadding: 1 + checkPaddingRequired: 0 + m_isRichText: 1 + m_parseCtrlCharacters: 1 + m_isOrthographic: 1 + m_isCullingEnabled: 0 + m_horizontalMapping: 0 + m_verticalMapping: 0 + m_uvLineOffset: 0 + m_geometrySortingOrder: 0 + m_IsTextObjectScaleStatic: 0 + m_VertexBufferAutoSizeReduction: 0 + m_useMaxVisibleDescender: 1 + m_pageToDisplay: 1 + m_margin: {x: 0, y: 0, z: 0, w: 0} + m_isUsingLegacyAnimationComponent: 0 + m_isVolumetricText: 0 + m_hasFontAssetChanged: 0 + m_baseMaterial: {fileID: 0} + m_maskOffset: {x: 0, y: 0, z: 0, w: 0} +--- !u!114 &4359144213886098624 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4359144213886098626} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 306cc8c2b49d7114eaa3623786fc2126, type: 3} + m_Name: + m_EditorClassIdentifier: + m_IgnoreLayout: 1 + m_MinWidth: -1 + m_MinHeight: -1 + m_PreferredWidth: -1 + m_PreferredHeight: -1 + m_FlexibleWidth: -1 + m_FlexibleHeight: -1 + m_LayoutPriority: 1 +--- !u!1 &4359144213961278873 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 4359144213961278872} + m_Layer: 5 + m_Name: toggle + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &4359144213961278872 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4359144213961278873} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: + - {fileID: 4359144214652122538} + m_Father: {fileID: 4359144215414896298} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 0, y: 0} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 22, y: 40} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!1 &4359144214073569384 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 4359144214073569399} + - component: {fileID: 4359144214073569396} + - component: {fileID: 4359144214073569397} + - component: {fileID: 4359144214073569398} + m_Layer: 5 + m_Name: Placeholder + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 0 +--- !u!224 &4359144214073569399 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4359144214073569384} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: [] + m_Father: {fileID: 4359144214931836700} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 0, y: 0} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &4359144214073569396 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4359144214073569384} + m_CullTransparentMesh: 1 +--- !u!114 &4359144214073569397 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4359144214073569384} + m_Enabled: 0 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: f4688fdb7df04437aeb418b961361dc5, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_text: 125 + m_isRightToLeft: 0 + m_fontAsset: {fileID: 11400000, guid: 713219d18e2f8c440b4e4435211afb23, type: 2} + m_sharedMaterial: {fileID: -1567122069935691074, guid: 713219d18e2f8c440b4e4435211afb23, type: 2} + m_fontSharedMaterials: [] + m_fontMaterial: {fileID: 0} + m_fontMaterials: [] + m_fontColor32: + serializedVersion: 2 + rgba: 4281479730 + m_fontColor: {r: 0.19607843, g: 0.19607843, b: 0.19607843, a: 1} + m_enableVertexGradient: 0 + m_colorMode: 3 + m_fontColorGradient: + topLeft: {r: 1, g: 1, b: 1, a: 1} + topRight: {r: 1, g: 1, b: 1, a: 1} + bottomLeft: {r: 1, g: 1, b: 1, a: 1} + bottomRight: {r: 1, g: 1, b: 1, a: 1} + m_fontColorGradientPreset: {fileID: 0} + m_spriteAsset: {fileID: 0} + m_tintAllSprites: 0 + m_StyleSheet: {fileID: 0} + m_TextStyleHashCode: -1183493901 + m_overrideHtmlColors: 0 + m_faceColor: + serializedVersion: 2 + rgba: 4294967295 + m_fontSize: 14 + m_fontSizeBase: 14 + m_fontWeight: 400 + m_enableAutoSizing: 0 + m_fontSizeMin: 18 + m_fontSizeMax: 72 + m_fontStyle: 0 + m_HorizontalAlignment: 2 + m_VerticalAlignment: 512 + m_textAlignment: 65535 + m_characterSpacing: 0 + m_wordSpacing: 0 + m_lineSpacing: 0 + m_lineSpacingMax: 0 + m_paragraphSpacing: 0 + m_charWidthMaxAdj: 0 + m_enableWordWrapping: 0 + m_wordWrappingRatios: 0.4 + m_overflowMode: 0 + m_linkedTextComponent: {fileID: 0} + parentLinkedComponent: {fileID: 0} + m_enableKerning: 1 + m_enableExtraPadding: 1 + checkPaddingRequired: 0 + m_isRichText: 1 + m_parseCtrlCharacters: 1 + m_isOrthographic: 1 + m_isCullingEnabled: 0 + m_horizontalMapping: 0 + m_verticalMapping: 0 + m_uvLineOffset: 0 + m_geometrySortingOrder: 0 + m_IsTextObjectScaleStatic: 0 + m_VertexBufferAutoSizeReduction: 0 + m_useMaxVisibleDescender: 1 + m_pageToDisplay: 1 + m_margin: {x: 0, y: 0, z: 0, w: 0} + m_isUsingLegacyAnimationComponent: 0 + m_isVolumetricText: 0 + m_hasFontAssetChanged: 0 + m_baseMaterial: {fileID: 0} + m_maskOffset: {x: 0, y: 0, z: 0, w: 0} +--- !u!114 &4359144214073569398 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4359144214073569384} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 306cc8c2b49d7114eaa3623786fc2126, type: 3} + m_Name: + m_EditorClassIdentifier: + m_IgnoreLayout: 1 + m_MinWidth: -1 + m_MinHeight: -1 + m_PreferredWidth: -1 + m_PreferredHeight: -1 + m_FlexibleWidth: -1 + m_FlexibleHeight: -1 + m_LayoutPriority: 1 +--- !u!1 &4359144214652122539 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 4359144214652122538} + - component: {fileID: 4359144214652122537} + m_Layer: 5 + m_Name: Toggle + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &4359144214652122538 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4359144214652122539} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: + - {fileID: 4359144215423301718} + - {fileID: 4359144214757625871} + m_Father: {fileID: 4359144213961278872} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0.5} + m_AnchorMax: {x: 0, y: 0.5} + m_AnchoredPosition: {x: 0, y: -0.000015258789} + m_SizeDelta: {x: 16, y: 16} + m_Pivot: {x: 0, y: 0.5} +--- !u!114 &4359144214652122537 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4359144214652122539} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 9085046f02f69544eb97fd06b6048fe2, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Navigation: + m_Mode: 3 + m_WrapAround: 0 + m_SelectOnUp: {fileID: 0} + m_SelectOnDown: {fileID: 0} + m_SelectOnLeft: {fileID: 0} + m_SelectOnRight: {fileID: 0} + m_Transition: 1 + m_Colors: + m_NormalColor: {r: 1, g: 1, b: 1, a: 1} + m_HighlightedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} + m_PressedColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 1} + m_SelectedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} + m_DisabledColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 0.5019608} + m_ColorMultiplier: 1 + m_FadeDuration: 0.1 + m_SpriteState: + m_HighlightedSprite: {fileID: 0} + m_PressedSprite: {fileID: 0} + m_SelectedSprite: {fileID: 0} + m_DisabledSprite: {fileID: 0} + m_AnimationTriggers: + m_NormalTrigger: Normal + m_HighlightedTrigger: Highlighted + m_PressedTrigger: Pressed + m_SelectedTrigger: Selected + m_DisabledTrigger: Disabled + m_Interactable: 1 + m_TargetGraphic: {fileID: 4359144215423301717} + toggleTransition: 1 + graphic: {fileID: 4359144214757625870} + m_Group: {fileID: 0} + onValueChanged: + m_PersistentCalls: + m_Calls: [] + m_IsOn: 0 +--- !u!1 &4359144214696212394 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 4359144214696212407} + - component: {fileID: 4359144214696212392} + - component: {fileID: 4359144214696212393} + m_Layer: 5 + m_Name: Text + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &4359144214696212407 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4359144214696212394} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: [] + m_Father: {fileID: 4359144215278372545} + m_RootOrder: 1 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 0, y: 0} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &4359144214696212392 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4359144214696212394} + m_CullTransparentMesh: 1 +--- !u!114 &4359144214696212393 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4359144214696212394} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: f4688fdb7df04437aeb418b961361dc5, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_text: "NAN\u200B" + m_isRightToLeft: 0 + m_fontAsset: {fileID: 11400000, guid: 713219d18e2f8c440b4e4435211afb23, type: 2} + m_sharedMaterial: {fileID: -1567122069935691074, guid: 713219d18e2f8c440b4e4435211afb23, type: 2} + m_fontSharedMaterials: [] + m_fontMaterial: {fileID: 0} + m_fontMaterials: [] + m_fontColor32: + serializedVersion: 2 + rgba: 4281479730 + m_fontColor: {r: 0.19607843, g: 0.19607843, b: 0.19607843, a: 1} + m_enableVertexGradient: 0 + m_colorMode: 3 + m_fontColorGradient: + topLeft: {r: 1, g: 1, b: 1, a: 1} + topRight: {r: 1, g: 1, b: 1, a: 1} + bottomLeft: {r: 1, g: 1, b: 1, a: 1} + bottomRight: {r: 1, g: 1, b: 1, a: 1} + m_fontColorGradientPreset: {fileID: 0} + m_spriteAsset: {fileID: 0} + m_tintAllSprites: 0 + m_StyleSheet: {fileID: 0} + m_TextStyleHashCode: -1183493901 + m_overrideHtmlColors: 0 + m_faceColor: + serializedVersion: 2 + rgba: 4294967295 + m_fontSize: 14 + m_fontSizeBase: 14 + m_fontWeight: 400 + m_enableAutoSizing: 0 + m_fontSizeMin: 18 + m_fontSizeMax: 72 + m_fontStyle: 0 + m_HorizontalAlignment: 2 + m_VerticalAlignment: 512 + m_textAlignment: 65535 + m_characterSpacing: 0 + m_wordSpacing: 0 + m_lineSpacing: 0 + m_lineSpacingMax: 0 + m_paragraphSpacing: 0 + m_charWidthMaxAdj: 0 + m_enableWordWrapping: 0 + m_wordWrappingRatios: 0.4 + m_overflowMode: 0 + m_linkedTextComponent: {fileID: 0} + parentLinkedComponent: {fileID: 0} + m_enableKerning: 1 + m_enableExtraPadding: 1 + checkPaddingRequired: 0 + m_isRichText: 1 + m_parseCtrlCharacters: 1 + m_isOrthographic: 1 + m_isCullingEnabled: 0 + m_horizontalMapping: 0 + m_verticalMapping: 0 + m_uvLineOffset: 0 + m_geometrySortingOrder: 0 + m_IsTextObjectScaleStatic: 0 + m_VertexBufferAutoSizeReduction: 0 + m_useMaxVisibleDescender: 1 + m_pageToDisplay: 1 + m_margin: {x: 0, y: 0, z: 0, w: 0} + m_isUsingLegacyAnimationComponent: 0 + m_isVolumetricText: 0 + m_hasFontAssetChanged: 0 + m_baseMaterial: {fileID: 0} + m_maskOffset: {x: 0, y: 0, z: 0, w: 0} +--- !u!1 &4359144214757625856 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 4359144214757625871} + - component: {fileID: 4359144214757625869} + - component: {fileID: 4359144214757625870} + m_Layer: 5 + m_Name: Checkmark + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &4359144214757625871 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4359144214757625856} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: [] + m_Father: {fileID: 4359144214652122538} + m_RootOrder: 1 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: -0.00000014901161, y: 0.00000013579847} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &4359144214757625869 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4359144214757625856} + m_CullTransparentMesh: 1 +--- !u!114 &4359144214757625870 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4359144214757625856} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_Sprite: {fileID: 21300000, guid: 1f2a868175c8a8a47a887eea9056fe28, type: 3} + m_Type: 0 + m_PreserveAspect: 0 + m_FillCenter: 1 + m_FillMethod: 4 + m_FillAmount: 1 + m_FillClockwise: 1 + m_FillOrigin: 0 + m_UseSpriteMesh: 0 + m_PixelsPerUnitMultiplier: 1 +--- !u!1 &4359144214931836701 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 4359144214931836700} + - component: {fileID: 4359144214931836699} + m_Layer: 5 + m_Name: Text Area + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &4359144214931836700 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4359144214931836701} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: + - {fileID: 4359144214073569399} + - {fileID: 4359144213813927356} + m_Father: {fileID: 4359144215583261840} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: -0.5} + m_SizeDelta: {x: -20, y: -13} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!114 &4359144214931836699 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4359144214931836701} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 3312d7739989d2b4e91e6319e9a96d76, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Padding: {x: -8, y: -5, z: -8, w: -5} + m_Softness: {x: 0, y: 0} +--- !u!1 &4359144215230649444 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 4359144215230649443} + - component: {fileID: 4359144215230649441} + - component: {fileID: 4359144215230649442} + m_Layer: 5 + m_Name: title + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &4359144215230649443 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4359144215230649444} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: + - {fileID: 14857631821254170} + m_Father: {fileID: 4359144215414896298} + m_RootOrder: 1 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 0, y: 0} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 120, y: 40} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &4359144215230649441 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4359144215230649444} + m_CullTransparentMesh: 1 +--- !u!114 &4359144215230649442 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4359144215230649444} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: f4688fdb7df04437aeb418b961361dc5, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_text: + m_isRightToLeft: 0 + m_fontAsset: {fileID: 11400000, guid: 3bd21f304e77db54eb98a1f35f6a2680, type: 2} + m_sharedMaterial: {fileID: -3509209986637506031, guid: 3bd21f304e77db54eb98a1f35f6a2680, type: 2} + m_fontSharedMaterials: [] + m_fontMaterial: {fileID: 0} + m_fontMaterials: [] + m_fontColor32: + serializedVersion: 2 + rgba: 4278190080 + m_fontColor: {r: 0, g: 0, b: 0, a: 1} + m_enableVertexGradient: 0 + m_colorMode: 3 + m_fontColorGradient: + topLeft: {r: 1, g: 1, b: 1, a: 1} + topRight: {r: 1, g: 1, b: 1, a: 1} + bottomLeft: {r: 1, g: 1, b: 1, a: 1} + bottomRight: {r: 1, g: 1, b: 1, a: 1} + m_fontColorGradientPreset: {fileID: 0} + m_spriteAsset: {fileID: 0} + m_tintAllSprites: 0 + m_StyleSheet: {fileID: 0} + m_TextStyleHashCode: -1183493901 + m_overrideHtmlColors: 0 + m_faceColor: + serializedVersion: 2 + rgba: 4294967295 + m_fontSize: 16 + m_fontSizeBase: 16 + m_fontWeight: 400 + m_enableAutoSizing: 0 + m_fontSizeMin: 18 + m_fontSizeMax: 72 + m_fontStyle: 0 + m_HorizontalAlignment: 1 + m_VerticalAlignment: 512 + m_textAlignment: 65535 + m_characterSpacing: 0 + m_wordSpacing: 0 + m_lineSpacing: 0 + m_lineSpacingMax: 0 + m_paragraphSpacing: 0 + m_charWidthMaxAdj: 0 + m_enableWordWrapping: 1 + m_wordWrappingRatios: 0.4 + m_overflowMode: 0 + m_linkedTextComponent: {fileID: 0} + parentLinkedComponent: {fileID: 0} + m_enableKerning: 1 + m_enableExtraPadding: 0 + checkPaddingRequired: 0 + m_isRichText: 1 + m_parseCtrlCharacters: 1 + m_isOrthographic: 1 + m_isCullingEnabled: 0 + m_horizontalMapping: 0 + m_verticalMapping: 0 + m_uvLineOffset: 0 + m_geometrySortingOrder: 0 + m_IsTextObjectScaleStatic: 0 + m_VertexBufferAutoSizeReduction: 0 + m_useMaxVisibleDescender: 1 + m_pageToDisplay: 1 + m_margin: {x: 0, y: -1.5838165, z: 0, w: 0} + m_isUsingLegacyAnimationComponent: 0 + m_isVolumetricText: 0 + m_hasFontAssetChanged: 0 + m_baseMaterial: {fileID: 0} + m_maskOffset: {x: 0, y: 0, z: 0, w: 0} +--- !u!1 &4359144215278372546 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 4359144215278372545} + - component: {fileID: 4359144215278372544} + m_Layer: 5 + m_Name: Text Area + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &4359144215278372545 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4359144215278372546} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: + - {fileID: 4359144213886098638} + - {fileID: 4359144214696212407} + m_Father: {fileID: 4359144213727891026} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: -0.5} + m_SizeDelta: {x: -20, y: -13} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!114 &4359144215278372544 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4359144215278372546} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 3312d7739989d2b4e91e6319e9a96d76, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Padding: {x: -8, y: -5, z: -8, w: -5} + m_Softness: {x: 0, y: 0} +--- !u!1 &4359144215414896299 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 4359144215414896298} + - component: {fileID: 4359144215414896297} + - component: {fileID: 4359144215414896296} + m_Layer: 5 + m_Name: ConfigInputVec2 + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &4359144215414896298 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4359144215414896299} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: + - {fileID: 4359144213961278872} + - {fileID: 4359144215230649443} + - {fileID: 4359144213727891026} + - {fileID: 4359144215583261840} + m_Father: {fileID: 0} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0.5, y: 1} + m_AnchorMax: {x: 0.5, y: 1} + m_AnchoredPosition: {x: -100, y: -300} + m_SizeDelta: {x: 320, y: 40} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!114 &4359144215414896297 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4359144215414896299} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 118ff8f18137da54087c6d572fc5db75, type: 3} + m_Name: + m_EditorClassIdentifier: + configTag: + allowInput: 1 + autoUpdateValue: 1 + allowBlockUpdate: 1 + forceBlockUpdate: 0 + numberFormat: 0.## + titleLabel: {fileID: 4359144215230649442} + titleTextContext: + helpLabel: {fileID: 4883949217999211411} + helpTextContext: + unitLabel: {fileID: 0} + unitTextContext: + autoUpdateValueToggle: {fileID: 4359144214652122537} + autoUpdateValueToggleReversalState: 0 + autoUpdateValueReversalState: 1 + dirtyAutoReset: 0 + editorInput: {x: 0, y: 0} + targetInputX: {fileID: 4359144213727891029} + targetInputY: {fileID: 4359144215583261855} +--- !u!114 &4359144215414896296 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4359144215414896299} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 30649d3a9faa99c48a7b1166b86bf2a0, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Padding: + m_Left: 0 + m_Right: 0 + m_Top: 0 + m_Bottom: 0 + m_ChildAlignment: 3 + m_Spacing: 0 + m_ChildForceExpandWidth: 1 + m_ChildForceExpandHeight: 1 + m_ChildControlWidth: 0 + m_ChildControlHeight: 0 + m_ChildScaleWidth: 0 + m_ChildScaleHeight: 0 + m_ReverseArrangement: 0 +--- !u!1 &4359144215423301719 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 4359144215423301718} + - component: {fileID: 4359144215423301716} + - component: {fileID: 4359144215423301717} + m_Layer: 5 + m_Name: Background + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &4359144215423301718 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4359144215423301719} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: [] + m_Father: {fileID: 4359144214652122538} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0.03426361, y: 0.00049591064} + m_SizeDelta: {x: 0.065603256, y: 0.00012207031} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &4359144215423301716 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4359144215423301719} + m_CullTransparentMesh: 1 +--- !u!114 &4359144215423301717 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4359144215423301719} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_Sprite: {fileID: 21300000, guid: 56a95a2d9d13e774093a51bcbebb8e7f, type: 3} + m_Type: 0 + m_PreserveAspect: 0 + m_FillCenter: 1 + m_FillMethod: 4 + m_FillAmount: 1 + m_FillClockwise: 1 + m_FillOrigin: 0 + m_UseSpriteMesh: 0 + m_PixelsPerUnitMultiplier: 1 +--- !u!1 &4359144215583261841 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 4359144215583261840} + - component: {fileID: 4359144215583261853} + - component: {fileID: 4359144215583261854} + - component: {fileID: 4359144215583261855} + m_Layer: 5 + m_Name: inputy + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &4359144215583261840 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4359144215583261841} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: + - {fileID: 4359144214931836700} + m_Father: {fileID: 4359144215414896298} + m_RootOrder: 3 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 0, y: 0} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 90, y: 35} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &4359144215583261853 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4359144215583261841} + m_CullTransparentMesh: 1 +--- !u!114 &4359144215583261854 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4359144215583261841} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_Sprite: {fileID: 21300000, guid: c9036691e9378664ea18dc8a90cfa180, type: 3} + m_Type: 0 + m_PreserveAspect: 0 + m_FillCenter: 1 + m_FillMethod: 4 + m_FillAmount: 1 + m_FillClockwise: 1 + m_FillOrigin: 0 + m_UseSpriteMesh: 0 + m_PixelsPerUnitMultiplier: 1 +--- !u!114 &4359144215583261855 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4359144215583261841} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 2da0c512f12947e489f739169773d7ca, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Navigation: + m_Mode: 3 + m_WrapAround: 0 + m_SelectOnUp: {fileID: 0} + m_SelectOnDown: {fileID: 0} + m_SelectOnLeft: {fileID: 0} + m_SelectOnRight: {fileID: 0} + m_Transition: 1 + m_Colors: + m_NormalColor: {r: 1, g: 1, b: 1, a: 1} + m_HighlightedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} + m_PressedColor: {r: 0.4268423, g: 0.66566586, b: 0.8301887, a: 1} + m_SelectedColor: {r: 0.42745098, g: 0.6666667, b: 0.83137256, a: 1} + m_DisabledColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 0.5019608} + m_ColorMultiplier: 1 + m_FadeDuration: 0.1 + m_SpriteState: + m_HighlightedSprite: {fileID: 0} + m_PressedSprite: {fileID: 0} + m_SelectedSprite: {fileID: 0} + m_DisabledSprite: {fileID: 0} + m_AnimationTriggers: + m_NormalTrigger: Normal + m_HighlightedTrigger: Highlighted + m_PressedTrigger: Pressed + m_SelectedTrigger: Selected + m_DisabledTrigger: Disabled + m_Interactable: 1 + m_TargetGraphic: {fileID: 4359144215583261854} + m_TextViewport: {fileID: 4359144214931836700} + m_TextComponent: {fileID: 4359144213813927355} + m_Placeholder: {fileID: 4359144214073569397} + m_VerticalScrollbar: {fileID: 0} + m_VerticalScrollbarEventHandler: {fileID: 0} + m_LayoutGroup: {fileID: 0} + m_ScrollSensitivity: 1 + m_ContentType: 0 + m_InputType: 0 + m_AsteriskChar: 42 + m_KeyboardType: 0 + m_LineType: 0 + m_HideMobileInput: 0 + m_HideSoftKeyboard: 0 + m_CharacterValidation: 0 + m_RegexValue: + m_GlobalPointSize: 14 + m_CharacterLimit: 0 + m_OnEndEdit: + m_PersistentCalls: + m_Calls: [] + m_OnSubmit: + m_PersistentCalls: + m_Calls: [] + m_OnSelect: + m_PersistentCalls: + m_Calls: [] + m_OnDeselect: + m_PersistentCalls: + m_Calls: [] + m_OnTextSelection: + m_PersistentCalls: + m_Calls: [] + m_OnEndTextSelection: + m_PersistentCalls: + m_Calls: [] + m_OnValueChanged: + m_PersistentCalls: + m_Calls: [] + m_OnTouchScreenKeyboardStatusChanged: + m_PersistentCalls: + m_Calls: [] + m_CaretColor: {r: 0.19607843, g: 0.19607843, b: 0.19607843, a: 1} + m_CustomCaretColor: 0 + m_SelectionColor: {r: 0.65882355, g: 0.80784315, b: 1, a: 0.7529412} + m_Text: 0 + m_CaretBlinkRate: 0.85 + m_CaretWidth: 1 + m_ReadOnly: 0 + m_RichText: 1 + m_GlobalFontAsset: {fileID: 11400000, guid: 8f586378b4e144a9851e7b34d9b748ee, type: 2} + m_OnFocusSelectAll: 1 + m_ResetOnDeActivation: 1 + m_RestoreOriginalTextOnEscape: 1 + m_isRichTextEditingAllowed: 0 + m_LineLimit: 0 + m_InputValidator: {fileID: 0} +--- !u!1 &4940109413883339957 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 14857631821254170} + - component: {fileID: 5192226417979595282} + - component: {fileID: 4883949217999211411} + m_Layer: 5 + m_Name: help + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &14857631821254170 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4940109413883339957} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: [] + m_Father: {fileID: 4359144215230649443} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 1} + m_AnchorMax: {x: 0, y: 1} + m_AnchoredPosition: {x: 0, y: -35} + m_SizeDelta: {x: 300, y: 50} + m_Pivot: {x: 0, y: 1} +--- !u!222 &5192226417979595282 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4940109413883339957} + m_CullTransparentMesh: 1 +--- !u!114 &4883949217999211411 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4940109413883339957} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: f4688fdb7df04437aeb418b961361dc5, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_text: + m_isRightToLeft: 0 + m_fontAsset: {fileID: 11400000, guid: 3bd21f304e77db54eb98a1f35f6a2680, type: 2} + m_sharedMaterial: {fileID: -3509209986637506031, guid: 3bd21f304e77db54eb98a1f35f6a2680, type: 2} + m_fontSharedMaterials: [] + m_fontMaterial: {fileID: 0} + m_fontMaterials: [] + m_fontColor32: + serializedVersion: 2 + rgba: 4278190335 + m_fontColor: {r: 1, g: 0, b: 0, a: 1} + m_enableVertexGradient: 0 + m_colorMode: 3 + m_fontColorGradient: + topLeft: {r: 1, g: 1, b: 1, a: 1} + topRight: {r: 1, g: 1, b: 1, a: 1} + bottomLeft: {r: 1, g: 1, b: 1, a: 1} + bottomRight: {r: 1, g: 1, b: 1, a: 1} + m_fontColorGradientPreset: {fileID: 0} + m_spriteAsset: {fileID: 0} + m_tintAllSprites: 0 + m_StyleSheet: {fileID: 0} + m_TextStyleHashCode: -1183493901 + m_overrideHtmlColors: 0 + m_faceColor: + serializedVersion: 2 + rgba: 4294967295 + m_fontSize: 14 + m_fontSizeBase: 14 + m_fontWeight: 400 + m_enableAutoSizing: 0 + m_fontSizeMin: 18 + m_fontSizeMax: 72 + m_fontStyle: 0 + m_HorizontalAlignment: 1 + m_VerticalAlignment: 256 + m_textAlignment: 65535 + m_characterSpacing: 0 + m_wordSpacing: 0 + m_lineSpacing: 0 + m_lineSpacingMax: 0 + m_paragraphSpacing: 0 + m_charWidthMaxAdj: 0 + m_enableWordWrapping: 1 + m_wordWrappingRatios: 0.4 + m_overflowMode: 0 + m_linkedTextComponent: {fileID: 0} + parentLinkedComponent: {fileID: 0} + m_enableKerning: 1 + m_enableExtraPadding: 0 + checkPaddingRequired: 0 + m_isRichText: 1 + m_parseCtrlCharacters: 1 + m_isOrthographic: 1 + m_isCullingEnabled: 0 + m_horizontalMapping: 0 + m_verticalMapping: 0 + m_uvLineOffset: 0 + m_geometrySortingOrder: 0 + m_IsTextObjectScaleStatic: 0 + m_VertexBufferAutoSizeReduction: 0 + m_useMaxVisibleDescender: 1 + m_pageToDisplay: 1 + m_margin: {x: 0, y: 0, z: 0, w: 0} + m_isUsingLegacyAnimationComponent: 0 + m_isVolumetricText: 0 + m_hasFontAssetChanged: 0 + m_baseMaterial: {fileID: 0} + m_maskOffset: {x: 0, y: 0, z: 0, w: 0} diff --git a/Resources/Prefab/ConfigUIItem/ConfigInputVec3.prefab b/Resources/Prefab/ConfigUIItem/ConfigInputVec3.prefab new file mode 100644 index 0000000..4bf93a8 --- /dev/null +++ b/Resources/Prefab/ConfigUIItem/ConfigInputVec3.prefab @@ -0,0 +1,2210 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!1 &2927271268099144310 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 2927271268099144297} + - component: {fileID: 2927271268099144298} + - component: {fileID: 2927271268099144299} + - component: {fileID: 2927271268099144296} + m_Layer: 5 + m_Name: Placeholder + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 0 +--- !u!224 &2927271268099144297 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271268099144310} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: [] + m_Father: {fileID: 2927271268927848411} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 0, y: 0} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &2927271268099144298 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271268099144310} + m_CullTransparentMesh: 1 +--- !u!114 &2927271268099144299 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271268099144310} + m_Enabled: 0 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: f4688fdb7df04437aeb418b961361dc5, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_text: 125 + m_isRightToLeft: 0 + m_fontAsset: {fileID: 11400000, guid: 713219d18e2f8c440b4e4435211afb23, type: 2} + m_sharedMaterial: {fileID: -1567122069935691074, guid: 713219d18e2f8c440b4e4435211afb23, type: 2} + m_fontSharedMaterials: [] + m_fontMaterial: {fileID: 0} + m_fontMaterials: [] + m_fontColor32: + serializedVersion: 2 + rgba: 4281479730 + m_fontColor: {r: 0.19607843, g: 0.19607843, b: 0.19607843, a: 1} + m_enableVertexGradient: 0 + m_colorMode: 3 + m_fontColorGradient: + topLeft: {r: 1, g: 1, b: 1, a: 1} + topRight: {r: 1, g: 1, b: 1, a: 1} + bottomLeft: {r: 1, g: 1, b: 1, a: 1} + bottomRight: {r: 1, g: 1, b: 1, a: 1} + m_fontColorGradientPreset: {fileID: 0} + m_spriteAsset: {fileID: 0} + m_tintAllSprites: 0 + m_StyleSheet: {fileID: 0} + m_TextStyleHashCode: -1183493901 + m_overrideHtmlColors: 0 + m_faceColor: + serializedVersion: 2 + rgba: 4294967295 + m_fontSize: 14 + m_fontSizeBase: 14 + m_fontWeight: 400 + m_enableAutoSizing: 0 + m_fontSizeMin: 18 + m_fontSizeMax: 72 + m_fontStyle: 0 + m_HorizontalAlignment: 2 + m_VerticalAlignment: 512 + m_textAlignment: 65535 + m_characterSpacing: 0 + m_wordSpacing: 0 + m_lineSpacing: 0 + m_lineSpacingMax: 0 + m_paragraphSpacing: 0 + m_charWidthMaxAdj: 0 + m_enableWordWrapping: 0 + m_wordWrappingRatios: 0.4 + m_overflowMode: 0 + m_linkedTextComponent: {fileID: 0} + parentLinkedComponent: {fileID: 0} + m_enableKerning: 1 + m_enableExtraPadding: 1 + checkPaddingRequired: 0 + m_isRichText: 1 + m_parseCtrlCharacters: 1 + m_isOrthographic: 1 + m_isCullingEnabled: 0 + m_horizontalMapping: 0 + m_verticalMapping: 0 + m_uvLineOffset: 0 + m_geometrySortingOrder: 0 + m_IsTextObjectScaleStatic: 0 + m_VertexBufferAutoSizeReduction: 0 + m_useMaxVisibleDescender: 1 + m_pageToDisplay: 1 + m_margin: {x: 0, y: 0, z: 0, w: 0} + m_isUsingLegacyAnimationComponent: 0 + m_isVolumetricText: 0 + m_hasFontAssetChanged: 0 + m_baseMaterial: {fileID: 0} + m_maskOffset: {x: 0, y: 0, z: 0, w: 0} +--- !u!114 &2927271268099144296 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271268099144310} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 306cc8c2b49d7114eaa3623786fc2126, type: 3} + m_Name: + m_EditorClassIdentifier: + m_IgnoreLayout: 1 + m_MinWidth: -1 + m_MinHeight: -1 + m_PreferredWidth: -1 + m_PreferredHeight: -1 + m_FlexibleWidth: -1 + m_FlexibleHeight: -1 + m_LayoutPriority: 1 +--- !u!1 &2927271268255631992 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 2927271268255631995} + - component: {fileID: 2927271268255631994} + m_Layer: 5 + m_Name: Text Area + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &2927271268255631995 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271268255631992} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: + - {fileID: 2927271268828292936} + - {fileID: 2927271268360546243} + m_Father: {fileID: 2927271269114347238} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: -0.5} + m_SizeDelta: {x: -20, y: -13} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!114 &2927271268255631994 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271268255631992} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 3312d7739989d2b4e91e6319e9a96d76, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Padding: {x: -8, y: -5, z: -8, w: -5} + m_Softness: {x: 0, y: 0} +--- !u!1 &2927271268360546254 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 2927271268360546243} + - component: {fileID: 2927271268360546240} + - component: {fileID: 2927271268360546241} + m_Layer: 5 + m_Name: Text + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &2927271268360546243 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271268360546254} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: [] + m_Father: {fileID: 2927271268255631995} + m_RootOrder: 1 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 0, y: 0} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &2927271268360546240 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271268360546254} + m_CullTransparentMesh: 1 +--- !u!114 &2927271268360546241 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271268360546254} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: f4688fdb7df04437aeb418b961361dc5, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_text: "NAN\u200B" + m_isRightToLeft: 0 + m_fontAsset: {fileID: 11400000, guid: 713219d18e2f8c440b4e4435211afb23, type: 2} + m_sharedMaterial: {fileID: -1567122069935691074, guid: 713219d18e2f8c440b4e4435211afb23, type: 2} + m_fontSharedMaterials: [] + m_fontMaterial: {fileID: 0} + m_fontMaterials: [] + m_fontColor32: + serializedVersion: 2 + rgba: 4281479730 + m_fontColor: {r: 0.19607843, g: 0.19607843, b: 0.19607843, a: 1} + m_enableVertexGradient: 0 + m_colorMode: 3 + m_fontColorGradient: + topLeft: {r: 1, g: 1, b: 1, a: 1} + topRight: {r: 1, g: 1, b: 1, a: 1} + bottomLeft: {r: 1, g: 1, b: 1, a: 1} + bottomRight: {r: 1, g: 1, b: 1, a: 1} + m_fontColorGradientPreset: {fileID: 0} + m_spriteAsset: {fileID: 0} + m_tintAllSprites: 0 + m_StyleSheet: {fileID: 0} + m_TextStyleHashCode: -1183493901 + m_overrideHtmlColors: 0 + m_faceColor: + serializedVersion: 2 + rgba: 4294967295 + m_fontSize: 14 + m_fontSizeBase: 14 + m_fontWeight: 400 + m_enableAutoSizing: 0 + m_fontSizeMin: 18 + m_fontSizeMax: 72 + m_fontStyle: 0 + m_HorizontalAlignment: 2 + m_VerticalAlignment: 512 + m_textAlignment: 65535 + m_characterSpacing: 0 + m_wordSpacing: 0 + m_lineSpacing: 0 + m_lineSpacingMax: 0 + m_paragraphSpacing: 0 + m_charWidthMaxAdj: 0 + m_enableWordWrapping: 0 + m_wordWrappingRatios: 0.4 + m_overflowMode: 0 + m_linkedTextComponent: {fileID: 0} + parentLinkedComponent: {fileID: 0} + m_enableKerning: 1 + m_enableExtraPadding: 1 + checkPaddingRequired: 0 + m_isRichText: 1 + m_parseCtrlCharacters: 1 + m_isOrthographic: 1 + m_isCullingEnabled: 0 + m_horizontalMapping: 0 + m_verticalMapping: 0 + m_uvLineOffset: 0 + m_geometrySortingOrder: 0 + m_IsTextObjectScaleStatic: 0 + m_VertexBufferAutoSizeReduction: 0 + m_useMaxVisibleDescender: 1 + m_pageToDisplay: 1 + m_margin: {x: 0, y: 0, z: 0, w: 0} + m_isUsingLegacyAnimationComponent: 0 + m_isVolumetricText: 0 + m_hasFontAssetChanged: 0 + m_baseMaterial: {fileID: 0} + m_maskOffset: {x: 0, y: 0, z: 0, w: 0} +--- !u!1 &2927271268390250473 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 2927271268390250472} + - component: {fileID: 2927271268390250477} + - component: {fileID: 2927271268390250474} + - component: {fileID: 2927271268390250475} + m_Layer: 5 + m_Name: Placeholder + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 0 +--- !u!224 &2927271268390250472 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271268390250473} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: [] + m_Father: {fileID: 2927271268811268914} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 0, y: 0} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &2927271268390250477 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271268390250473} + m_CullTransparentMesh: 1 +--- !u!114 &2927271268390250474 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271268390250473} + m_Enabled: 0 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: f4688fdb7df04437aeb418b961361dc5, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_text: 125 + m_isRightToLeft: 0 + m_fontAsset: {fileID: 11400000, guid: 713219d18e2f8c440b4e4435211afb23, type: 2} + m_sharedMaterial: {fileID: -1567122069935691074, guid: 713219d18e2f8c440b4e4435211afb23, type: 2} + m_fontSharedMaterials: [] + m_fontMaterial: {fileID: 0} + m_fontMaterials: [] + m_fontColor32: + serializedVersion: 2 + rgba: 4281479730 + m_fontColor: {r: 0.19607843, g: 0.19607843, b: 0.19607843, a: 1} + m_enableVertexGradient: 0 + m_colorMode: 3 + m_fontColorGradient: + topLeft: {r: 1, g: 1, b: 1, a: 1} + topRight: {r: 1, g: 1, b: 1, a: 1} + bottomLeft: {r: 1, g: 1, b: 1, a: 1} + bottomRight: {r: 1, g: 1, b: 1, a: 1} + m_fontColorGradientPreset: {fileID: 0} + m_spriteAsset: {fileID: 0} + m_tintAllSprites: 0 + m_StyleSheet: {fileID: 0} + m_TextStyleHashCode: -1183493901 + m_overrideHtmlColors: 0 + m_faceColor: + serializedVersion: 2 + rgba: 4294967295 + m_fontSize: 14 + m_fontSizeBase: 14 + m_fontWeight: 400 + m_enableAutoSizing: 0 + m_fontSizeMin: 18 + m_fontSizeMax: 72 + m_fontStyle: 0 + m_HorizontalAlignment: 2 + m_VerticalAlignment: 512 + m_textAlignment: 65535 + m_characterSpacing: 0 + m_wordSpacing: 0 + m_lineSpacing: 0 + m_lineSpacingMax: 0 + m_paragraphSpacing: 0 + m_charWidthMaxAdj: 0 + m_enableWordWrapping: 0 + m_wordWrappingRatios: 0.4 + m_overflowMode: 0 + m_linkedTextComponent: {fileID: 0} + parentLinkedComponent: {fileID: 0} + m_enableKerning: 1 + m_enableExtraPadding: 1 + checkPaddingRequired: 0 + m_isRichText: 1 + m_parseCtrlCharacters: 1 + m_isOrthographic: 1 + m_isCullingEnabled: 0 + m_horizontalMapping: 0 + m_verticalMapping: 0 + m_uvLineOffset: 0 + m_geometrySortingOrder: 0 + m_IsTextObjectScaleStatic: 0 + m_VertexBufferAutoSizeReduction: 0 + m_useMaxVisibleDescender: 1 + m_pageToDisplay: 1 + m_margin: {x: 0, y: 0, z: 0, w: 0} + m_isUsingLegacyAnimationComponent: 0 + m_isVolumetricText: 0 + m_hasFontAssetChanged: 0 + m_baseMaterial: {fileID: 0} + m_maskOffset: {x: 0, y: 0, z: 0, w: 0} +--- !u!114 &2927271268390250475 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271268390250473} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 306cc8c2b49d7114eaa3623786fc2126, type: 3} + m_Name: + m_EditorClassIdentifier: + m_IgnoreLayout: 1 + m_MinWidth: -1 + m_MinHeight: -1 + m_PreferredWidth: -1 + m_PreferredHeight: -1 + m_FlexibleWidth: -1 + m_FlexibleHeight: -1 + m_LayoutPriority: 1 +--- !u!1 &2927271268761643353 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 2927271268761643352} + - component: {fileID: 2927271268761643357} + - component: {fileID: 2927271268761643354} + - component: {fileID: 2927271268761643355} + m_Layer: 5 + m_Name: inputz + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &2927271268761643352 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271268761643353} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: + - {fileID: 2927271268811268914} + m_Father: {fileID: 2927271270070760197} + m_RootOrder: 4 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 0, y: 0} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 60, y: 35} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &2927271268761643357 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271268761643353} + m_CullTransparentMesh: 1 +--- !u!114 &2927271268761643354 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271268761643353} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_Sprite: {fileID: 21300000, guid: c9036691e9378664ea18dc8a90cfa180, type: 3} + m_Type: 0 + m_PreserveAspect: 0 + m_FillCenter: 1 + m_FillMethod: 4 + m_FillAmount: 1 + m_FillClockwise: 1 + m_FillOrigin: 0 + m_UseSpriteMesh: 0 + m_PixelsPerUnitMultiplier: 1 +--- !u!114 &2927271268761643355 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271268761643353} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 2da0c512f12947e489f739169773d7ca, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Navigation: + m_Mode: 3 + m_WrapAround: 0 + m_SelectOnUp: {fileID: 0} + m_SelectOnDown: {fileID: 0} + m_SelectOnLeft: {fileID: 0} + m_SelectOnRight: {fileID: 0} + m_Transition: 1 + m_Colors: + m_NormalColor: {r: 1, g: 1, b: 1, a: 1} + m_HighlightedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} + m_PressedColor: {r: 0.4268423, g: 0.66566586, b: 0.8301887, a: 1} + m_SelectedColor: {r: 0.42745098, g: 0.6666667, b: 0.83137256, a: 1} + m_DisabledColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 0.5019608} + m_ColorMultiplier: 1 + m_FadeDuration: 0.1 + m_SpriteState: + m_HighlightedSprite: {fileID: 0} + m_PressedSprite: {fileID: 0} + m_SelectedSprite: {fileID: 0} + m_DisabledSprite: {fileID: 0} + m_AnimationTriggers: + m_NormalTrigger: Normal + m_HighlightedTrigger: Highlighted + m_PressedTrigger: Pressed + m_SelectedTrigger: Selected + m_DisabledTrigger: Disabled + m_Interactable: 1 + m_TargetGraphic: {fileID: 2927271268761643354} + m_TextViewport: {fileID: 2927271268811268914} + m_TextComponent: {fileID: 2927271270073750015} + m_Placeholder: {fileID: 2927271268390250474} + m_VerticalScrollbar: {fileID: 0} + m_VerticalScrollbarEventHandler: {fileID: 0} + m_LayoutGroup: {fileID: 0} + m_ScrollSensitivity: 1 + m_ContentType: 0 + m_InputType: 0 + m_AsteriskChar: 42 + m_KeyboardType: 0 + m_LineType: 0 + m_HideMobileInput: 0 + m_HideSoftKeyboard: 0 + m_CharacterValidation: 0 + m_RegexValue: + m_GlobalPointSize: 14 + m_CharacterLimit: 0 + m_OnEndEdit: + m_PersistentCalls: + m_Calls: [] + m_OnSubmit: + m_PersistentCalls: + m_Calls: [] + m_OnSelect: + m_PersistentCalls: + m_Calls: [] + m_OnDeselect: + m_PersistentCalls: + m_Calls: [] + m_OnTextSelection: + m_PersistentCalls: + m_Calls: [] + m_OnEndTextSelection: + m_PersistentCalls: + m_Calls: [] + m_OnValueChanged: + m_PersistentCalls: + m_Calls: [] + m_OnTouchScreenKeyboardStatusChanged: + m_PersistentCalls: + m_Calls: [] + m_CaretColor: {r: 0.19607843, g: 0.19607843, b: 0.19607843, a: 1} + m_CustomCaretColor: 0 + m_SelectionColor: {r: 0.65882355, g: 0.80784315, b: 1, a: 0.7529412} + m_Text: 0 + m_CaretBlinkRate: 0.85 + m_CaretWidth: 1 + m_ReadOnly: 0 + m_RichText: 1 + m_GlobalFontAsset: {fileID: 11400000, guid: 8f586378b4e144a9851e7b34d9b748ee, type: 2} + m_OnFocusSelectAll: 1 + m_ResetOnDeActivation: 1 + m_RestoreOriginalTextOnEscape: 1 + m_isRichTextEditingAllowed: 0 + m_LineLimit: 0 + m_InputValidator: {fileID: 0} +--- !u!1 &2927271268811268915 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 2927271268811268914} + - component: {fileID: 2927271268811268917} + m_Layer: 5 + m_Name: Text Area + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &2927271268811268914 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271268811268915} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: + - {fileID: 2927271268390250472} + - {fileID: 2927271270073750012} + m_Father: {fileID: 2927271268761643352} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: -0.5} + m_SizeDelta: {x: -20, y: -13} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!114 &2927271268811268917 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271268811268915} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 3312d7739989d2b4e91e6319e9a96d76, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Padding: {x: -8, y: -5, z: -8, w: -5} + m_Softness: {x: 0, y: 0} +--- !u!1 &2927271268828292948 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 2927271268828292936} + - component: {fileID: 2927271268828292937} + - component: {fileID: 2927271268828292951} + - component: {fileID: 2927271268828292950} + m_Layer: 5 + m_Name: Placeholder + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 0 +--- !u!224 &2927271268828292936 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271268828292948} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: [] + m_Father: {fileID: 2927271268255631995} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 0, y: 0} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &2927271268828292937 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271268828292948} + m_CullTransparentMesh: 1 +--- !u!114 &2927271268828292951 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271268828292948} + m_Enabled: 0 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: f4688fdb7df04437aeb418b961361dc5, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_text: 125 + m_isRightToLeft: 0 + m_fontAsset: {fileID: 11400000, guid: 713219d18e2f8c440b4e4435211afb23, type: 2} + m_sharedMaterial: {fileID: -1567122069935691074, guid: 713219d18e2f8c440b4e4435211afb23, type: 2} + m_fontSharedMaterials: [] + m_fontMaterial: {fileID: 0} + m_fontMaterials: [] + m_fontColor32: + serializedVersion: 2 + rgba: 4281479730 + m_fontColor: {r: 0.19607843, g: 0.19607843, b: 0.19607843, a: 1} + m_enableVertexGradient: 0 + m_colorMode: 3 + m_fontColorGradient: + topLeft: {r: 1, g: 1, b: 1, a: 1} + topRight: {r: 1, g: 1, b: 1, a: 1} + bottomLeft: {r: 1, g: 1, b: 1, a: 1} + bottomRight: {r: 1, g: 1, b: 1, a: 1} + m_fontColorGradientPreset: {fileID: 0} + m_spriteAsset: {fileID: 0} + m_tintAllSprites: 0 + m_StyleSheet: {fileID: 0} + m_TextStyleHashCode: -1183493901 + m_overrideHtmlColors: 0 + m_faceColor: + serializedVersion: 2 + rgba: 4294967295 + m_fontSize: 14 + m_fontSizeBase: 14 + m_fontWeight: 400 + m_enableAutoSizing: 0 + m_fontSizeMin: 18 + m_fontSizeMax: 72 + m_fontStyle: 0 + m_HorizontalAlignment: 2 + m_VerticalAlignment: 512 + m_textAlignment: 65535 + m_characterSpacing: 0 + m_wordSpacing: 0 + m_lineSpacing: 0 + m_lineSpacingMax: 0 + m_paragraphSpacing: 0 + m_charWidthMaxAdj: 0 + m_enableWordWrapping: 0 + m_wordWrappingRatios: 0.4 + m_overflowMode: 0 + m_linkedTextComponent: {fileID: 0} + parentLinkedComponent: {fileID: 0} + m_enableKerning: 1 + m_enableExtraPadding: 1 + checkPaddingRequired: 0 + m_isRichText: 1 + m_parseCtrlCharacters: 1 + m_isOrthographic: 1 + m_isCullingEnabled: 0 + m_horizontalMapping: 0 + m_verticalMapping: 0 + m_uvLineOffset: 0 + m_geometrySortingOrder: 0 + m_IsTextObjectScaleStatic: 0 + m_VertexBufferAutoSizeReduction: 0 + m_useMaxVisibleDescender: 1 + m_pageToDisplay: 1 + m_margin: {x: 0, y: 0, z: 0, w: 0} + m_isUsingLegacyAnimationComponent: 0 + m_isVolumetricText: 0 + m_hasFontAssetChanged: 0 + m_baseMaterial: {fileID: 0} + m_maskOffset: {x: 0, y: 0, z: 0, w: 0} +--- !u!114 &2927271268828292950 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271268828292948} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 306cc8c2b49d7114eaa3623786fc2126, type: 3} + m_Name: + m_EditorClassIdentifier: + m_IgnoreLayout: 1 + m_MinWidth: -1 + m_MinHeight: -1 + m_PreferredWidth: -1 + m_PreferredHeight: -1 + m_FlexibleWidth: -1 + m_FlexibleHeight: -1 + m_LayoutPriority: 1 +--- !u!1 &2927271268904817447 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 2927271268904817446} + m_Layer: 5 + m_Name: toggle + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &2927271268904817446 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271268904817447} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: + - {fileID: 2927271269017926701} + m_Father: {fileID: 2927271270070760197} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 0, y: 0} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 22, y: 40} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!1 &2927271268927848408 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 2927271268927848411} + - component: {fileID: 2927271268927848410} + m_Layer: 5 + m_Name: Text Area + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &2927271268927848411 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271268927848408} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: + - {fileID: 2927271268099144297} + - {fileID: 2927271269316508807} + m_Father: {fileID: 2927271269830813757} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: -0.5} + m_SizeDelta: {x: -20, y: -13} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!114 &2927271268927848410 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271268927848408} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 3312d7739989d2b4e91e6319e9a96d76, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Padding: {x: -8, y: -5, z: -8, w: -5} + m_Softness: {x: 0, y: 0} +--- !u!1 &2927271269017926698 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 2927271269017926701} + - component: {fileID: 2927271269017926700} + m_Layer: 5 + m_Name: Toggle + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &2927271269017926701 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271269017926698} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: + - {fileID: 2927271269200226600} + - {fileID: 2927271269228766900} + m_Father: {fileID: 2927271268904817446} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0.5} + m_AnchorMax: {x: 0, y: 0.5} + m_AnchoredPosition: {x: 0, y: -0.000015258789} + m_SizeDelta: {x: 16, y: 16} + m_Pivot: {x: 0, y: 0.5} +--- !u!114 &2927271269017926700 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271269017926698} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 9085046f02f69544eb97fd06b6048fe2, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Navigation: + m_Mode: 3 + m_WrapAround: 0 + m_SelectOnUp: {fileID: 0} + m_SelectOnDown: {fileID: 0} + m_SelectOnLeft: {fileID: 0} + m_SelectOnRight: {fileID: 0} + m_Transition: 1 + m_Colors: + m_NormalColor: {r: 1, g: 1, b: 1, a: 1} + m_HighlightedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} + m_PressedColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 1} + m_SelectedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} + m_DisabledColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 0.5019608} + m_ColorMultiplier: 1 + m_FadeDuration: 0.1 + m_SpriteState: + m_HighlightedSprite: {fileID: 0} + m_PressedSprite: {fileID: 0} + m_SelectedSprite: {fileID: 0} + m_DisabledSprite: {fileID: 0} + m_AnimationTriggers: + m_NormalTrigger: Normal + m_HighlightedTrigger: Highlighted + m_PressedTrigger: Pressed + m_SelectedTrigger: Selected + m_DisabledTrigger: Disabled + m_Interactable: 1 + m_TargetGraphic: {fileID: 2927271269200226603} + toggleTransition: 1 + graphic: {fileID: 2927271269228766903} + m_Group: {fileID: 0} + onValueChanged: + m_PersistentCalls: + m_Calls: [] + m_IsOn: 0 +--- !u!1 &2927271269114347234 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 2927271269114347238} + - component: {fileID: 2927271269114347239} + - component: {fileID: 2927271269114347236} + - component: {fileID: 2927271269114347237} + m_Layer: 5 + m_Name: inputx + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &2927271269114347238 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271269114347234} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: + - {fileID: 2927271268255631995} + m_Father: {fileID: 2927271270070760197} + m_RootOrder: 2 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 0, y: 0} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 60, y: 35} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &2927271269114347239 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271269114347234} + m_CullTransparentMesh: 1 +--- !u!114 &2927271269114347236 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271269114347234} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_Sprite: {fileID: 21300000, guid: c9036691e9378664ea18dc8a90cfa180, type: 3} + m_Type: 0 + m_PreserveAspect: 0 + m_FillCenter: 1 + m_FillMethod: 4 + m_FillAmount: 1 + m_FillClockwise: 1 + m_FillOrigin: 0 + m_UseSpriteMesh: 0 + m_PixelsPerUnitMultiplier: 1 +--- !u!114 &2927271269114347237 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271269114347234} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 2da0c512f12947e489f739169773d7ca, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Navigation: + m_Mode: 3 + m_WrapAround: 0 + m_SelectOnUp: {fileID: 0} + m_SelectOnDown: {fileID: 0} + m_SelectOnLeft: {fileID: 0} + m_SelectOnRight: {fileID: 0} + m_Transition: 1 + m_Colors: + m_NormalColor: {r: 1, g: 1, b: 1, a: 1} + m_HighlightedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} + m_PressedColor: {r: 0.4268423, g: 0.66566586, b: 0.8301887, a: 1} + m_SelectedColor: {r: 0.42745098, g: 0.6666667, b: 0.83137256, a: 1} + m_DisabledColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 0.5019608} + m_ColorMultiplier: 1 + m_FadeDuration: 0.1 + m_SpriteState: + m_HighlightedSprite: {fileID: 0} + m_PressedSprite: {fileID: 0} + m_SelectedSprite: {fileID: 0} + m_DisabledSprite: {fileID: 0} + m_AnimationTriggers: + m_NormalTrigger: Normal + m_HighlightedTrigger: Highlighted + m_PressedTrigger: Pressed + m_SelectedTrigger: Selected + m_DisabledTrigger: Disabled + m_Interactable: 1 + m_TargetGraphic: {fileID: 2927271269114347236} + m_TextViewport: {fileID: 2927271268255631995} + m_TextComponent: {fileID: 2927271268360546241} + m_Placeholder: {fileID: 2927271268828292951} + m_VerticalScrollbar: {fileID: 0} + m_VerticalScrollbarEventHandler: {fileID: 0} + m_LayoutGroup: {fileID: 0} + m_ScrollSensitivity: 1 + m_ContentType: 0 + m_InputType: 0 + m_AsteriskChar: 42 + m_KeyboardType: 0 + m_LineType: 0 + m_HideMobileInput: 0 + m_HideSoftKeyboard: 0 + m_CharacterValidation: 0 + m_RegexValue: + m_GlobalPointSize: 14 + m_CharacterLimit: 0 + m_OnEndEdit: + m_PersistentCalls: + m_Calls: [] + m_OnSubmit: + m_PersistentCalls: + m_Calls: [] + m_OnSelect: + m_PersistentCalls: + m_Calls: [] + m_OnDeselect: + m_PersistentCalls: + m_Calls: [] + m_OnTextSelection: + m_PersistentCalls: + m_Calls: [] + m_OnEndTextSelection: + m_PersistentCalls: + m_Calls: [] + m_OnValueChanged: + m_PersistentCalls: + m_Calls: [] + m_OnTouchScreenKeyboardStatusChanged: + m_PersistentCalls: + m_Calls: [] + m_CaretColor: {r: 0.19607843, g: 0.19607843, b: 0.19607843, a: 1} + m_CustomCaretColor: 0 + m_SelectionColor: {r: 0.65882355, g: 0.80784315, b: 1, a: 0.7529412} + m_Text: 0 + m_CaretBlinkRate: 0.85 + m_CaretWidth: 1 + m_ReadOnly: 0 + m_RichText: 1 + m_GlobalFontAsset: {fileID: 11400000, guid: 8f586378b4e144a9851e7b34d9b748ee, type: 2} + m_OnFocusSelectAll: 1 + m_ResetOnDeActivation: 1 + m_RestoreOriginalTextOnEscape: 1 + m_isRichTextEditingAllowed: 0 + m_LineLimit: 0 + m_InputValidator: {fileID: 0} +--- !u!1 &2927271269163506455 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 2927271269163506454} + - component: {fileID: 2927271269163506440} + - component: {fileID: 2927271269163506441} + m_Layer: 5 + m_Name: title + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &2927271269163506454 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271269163506455} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: + - {fileID: 4508613349293898183} + m_Father: {fileID: 2927271270070760197} + m_RootOrder: 1 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 0, y: 0} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 120, y: 40} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &2927271269163506440 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271269163506455} + m_CullTransparentMesh: 1 +--- !u!114 &2927271269163506441 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271269163506455} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: f4688fdb7df04437aeb418b961361dc5, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_text: + m_isRightToLeft: 0 + m_fontAsset: {fileID: 11400000, guid: 3bd21f304e77db54eb98a1f35f6a2680, type: 2} + m_sharedMaterial: {fileID: -3509209986637506031, guid: 3bd21f304e77db54eb98a1f35f6a2680, type: 2} + m_fontSharedMaterials: [] + m_fontMaterial: {fileID: 0} + m_fontMaterials: [] + m_fontColor32: + serializedVersion: 2 + rgba: 4278190080 + m_fontColor: {r: 0, g: 0, b: 0, a: 1} + m_enableVertexGradient: 0 + m_colorMode: 3 + m_fontColorGradient: + topLeft: {r: 1, g: 1, b: 1, a: 1} + topRight: {r: 1, g: 1, b: 1, a: 1} + bottomLeft: {r: 1, g: 1, b: 1, a: 1} + bottomRight: {r: 1, g: 1, b: 1, a: 1} + m_fontColorGradientPreset: {fileID: 0} + m_spriteAsset: {fileID: 0} + m_tintAllSprites: 0 + m_StyleSheet: {fileID: 0} + m_TextStyleHashCode: -1183493901 + m_overrideHtmlColors: 0 + m_faceColor: + serializedVersion: 2 + rgba: 4294967295 + m_fontSize: 16 + m_fontSizeBase: 16 + m_fontWeight: 400 + m_enableAutoSizing: 0 + m_fontSizeMin: 18 + m_fontSizeMax: 72 + m_fontStyle: 0 + m_HorizontalAlignment: 1 + m_VerticalAlignment: 512 + m_textAlignment: 65535 + m_characterSpacing: 0 + m_wordSpacing: 0 + m_lineSpacing: 0 + m_lineSpacingMax: 0 + m_paragraphSpacing: 0 + m_charWidthMaxAdj: 0 + m_enableWordWrapping: 1 + m_wordWrappingRatios: 0.4 + m_overflowMode: 0 + m_linkedTextComponent: {fileID: 0} + parentLinkedComponent: {fileID: 0} + m_enableKerning: 1 + m_enableExtraPadding: 0 + checkPaddingRequired: 0 + m_isRichText: 1 + m_parseCtrlCharacters: 1 + m_isOrthographic: 1 + m_isCullingEnabled: 0 + m_horizontalMapping: 0 + m_verticalMapping: 0 + m_uvLineOffset: 0 + m_geometrySortingOrder: 0 + m_IsTextObjectScaleStatic: 0 + m_VertexBufferAutoSizeReduction: 0 + m_useMaxVisibleDescender: 1 + m_pageToDisplay: 1 + m_margin: {x: 0, y: -1.5838165, z: 0, w: 0} + m_isUsingLegacyAnimationComponent: 0 + m_isVolumetricText: 0 + m_hasFontAssetChanged: 0 + m_baseMaterial: {fileID: 0} + m_maskOffset: {x: 0, y: 0, z: 0, w: 0} +--- !u!1 &2927271269200226601 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 2927271269200226600} + - component: {fileID: 2927271269200226602} + - component: {fileID: 2927271269200226603} + m_Layer: 5 + m_Name: Background + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &2927271269200226600 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271269200226601} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: [] + m_Father: {fileID: 2927271269017926701} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0.03426361, y: 0.00049591064} + m_SizeDelta: {x: 0.065603256, y: 0.00012207031} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &2927271269200226602 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271269200226601} + m_CullTransparentMesh: 1 +--- !u!114 &2927271269200226603 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271269200226601} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_Sprite: {fileID: 21300000, guid: 56a95a2d9d13e774093a51bcbebb8e7f, type: 3} + m_Type: 0 + m_PreserveAspect: 0 + m_FillCenter: 1 + m_FillMethod: 4 + m_FillAmount: 1 + m_FillClockwise: 1 + m_FillOrigin: 0 + m_UseSpriteMesh: 0 + m_PixelsPerUnitMultiplier: 1 +--- !u!1 &2927271269228766901 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 2927271269228766900} + - component: {fileID: 2927271269228766902} + - component: {fileID: 2927271269228766903} + m_Layer: 5 + m_Name: Checkmark + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &2927271269228766900 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271269228766901} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: [] + m_Father: {fileID: 2927271269017926701} + m_RootOrder: 1 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: -0.00000014901161, y: 0.00000013579847} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &2927271269228766902 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271269228766901} + m_CullTransparentMesh: 1 +--- !u!114 &2927271269228766903 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271269228766901} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_Sprite: {fileID: 21300000, guid: 1f2a868175c8a8a47a887eea9056fe28, type: 3} + m_Type: 0 + m_PreserveAspect: 0 + m_FillCenter: 1 + m_FillMethod: 4 + m_FillAmount: 1 + m_FillClockwise: 1 + m_FillOrigin: 0 + m_UseSpriteMesh: 0 + m_PixelsPerUnitMultiplier: 1 +--- !u!1 &2927271269316508804 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 2927271269316508807} + - component: {fileID: 2927271269316508921} + - component: {fileID: 2927271269316508806} + m_Layer: 5 + m_Name: Text + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &2927271269316508807 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271269316508804} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: [] + m_Father: {fileID: 2927271268927848411} + m_RootOrder: 1 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 0, y: 0} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &2927271269316508921 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271269316508804} + m_CullTransparentMesh: 1 +--- !u!114 &2927271269316508806 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271269316508804} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: f4688fdb7df04437aeb418b961361dc5, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_text: "NAN\u200B" + m_isRightToLeft: 0 + m_fontAsset: {fileID: 11400000, guid: 713219d18e2f8c440b4e4435211afb23, type: 2} + m_sharedMaterial: {fileID: -1567122069935691074, guid: 713219d18e2f8c440b4e4435211afb23, type: 2} + m_fontSharedMaterials: [] + m_fontMaterial: {fileID: 0} + m_fontMaterials: [] + m_fontColor32: + serializedVersion: 2 + rgba: 4281479730 + m_fontColor: {r: 0.19607843, g: 0.19607843, b: 0.19607843, a: 1} + m_enableVertexGradient: 0 + m_colorMode: 3 + m_fontColorGradient: + topLeft: {r: 1, g: 1, b: 1, a: 1} + topRight: {r: 1, g: 1, b: 1, a: 1} + bottomLeft: {r: 1, g: 1, b: 1, a: 1} + bottomRight: {r: 1, g: 1, b: 1, a: 1} + m_fontColorGradientPreset: {fileID: 0} + m_spriteAsset: {fileID: 0} + m_tintAllSprites: 0 + m_StyleSheet: {fileID: 0} + m_TextStyleHashCode: -1183493901 + m_overrideHtmlColors: 0 + m_faceColor: + serializedVersion: 2 + rgba: 4294967295 + m_fontSize: 14 + m_fontSizeBase: 14 + m_fontWeight: 400 + m_enableAutoSizing: 0 + m_fontSizeMin: 18 + m_fontSizeMax: 72 + m_fontStyle: 0 + m_HorizontalAlignment: 2 + m_VerticalAlignment: 512 + m_textAlignment: 65535 + m_characterSpacing: 0 + m_wordSpacing: 0 + m_lineSpacing: 0 + m_lineSpacingMax: 0 + m_paragraphSpacing: 0 + m_charWidthMaxAdj: 0 + m_enableWordWrapping: 0 + m_wordWrappingRatios: 0.4 + m_overflowMode: 0 + m_linkedTextComponent: {fileID: 0} + parentLinkedComponent: {fileID: 0} + m_enableKerning: 1 + m_enableExtraPadding: 1 + checkPaddingRequired: 0 + m_isRichText: 1 + m_parseCtrlCharacters: 1 + m_isOrthographic: 1 + m_isCullingEnabled: 0 + m_horizontalMapping: 0 + m_verticalMapping: 0 + m_uvLineOffset: 0 + m_geometrySortingOrder: 0 + m_IsTextObjectScaleStatic: 0 + m_VertexBufferAutoSizeReduction: 0 + m_useMaxVisibleDescender: 1 + m_pageToDisplay: 1 + m_margin: {x: 0, y: 0, z: 0, w: 0} + m_isUsingLegacyAnimationComponent: 0 + m_isVolumetricText: 0 + m_hasFontAssetChanged: 0 + m_baseMaterial: {fileID: 0} + m_maskOffset: {x: 0, y: 0, z: 0, w: 0} +--- !u!1 &2927271269830813754 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 2927271269830813757} + - component: {fileID: 2927271269830813758} + - component: {fileID: 2927271269830813759} + - component: {fileID: 2927271269830813756} + m_Layer: 5 + m_Name: intputy + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &2927271269830813757 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271269830813754} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: + - {fileID: 2927271268927848411} + m_Father: {fileID: 2927271270070760197} + m_RootOrder: 3 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 0, y: 0} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 60, y: 35} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &2927271269830813758 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271269830813754} + m_CullTransparentMesh: 1 +--- !u!114 &2927271269830813759 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271269830813754} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_Sprite: {fileID: 21300000, guid: c9036691e9378664ea18dc8a90cfa180, type: 3} + m_Type: 0 + m_PreserveAspect: 0 + m_FillCenter: 1 + m_FillMethod: 4 + m_FillAmount: 1 + m_FillClockwise: 1 + m_FillOrigin: 0 + m_UseSpriteMesh: 0 + m_PixelsPerUnitMultiplier: 1 +--- !u!114 &2927271269830813756 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271269830813754} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 2da0c512f12947e489f739169773d7ca, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Navigation: + m_Mode: 3 + m_WrapAround: 0 + m_SelectOnUp: {fileID: 0} + m_SelectOnDown: {fileID: 0} + m_SelectOnLeft: {fileID: 0} + m_SelectOnRight: {fileID: 0} + m_Transition: 1 + m_Colors: + m_NormalColor: {r: 1, g: 1, b: 1, a: 1} + m_HighlightedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} + m_PressedColor: {r: 0.4268423, g: 0.66566586, b: 0.8301887, a: 1} + m_SelectedColor: {r: 0.42745098, g: 0.6666667, b: 0.83137256, a: 1} + m_DisabledColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 0.5019608} + m_ColorMultiplier: 1 + m_FadeDuration: 0.1 + m_SpriteState: + m_HighlightedSprite: {fileID: 0} + m_PressedSprite: {fileID: 0} + m_SelectedSprite: {fileID: 0} + m_DisabledSprite: {fileID: 0} + m_AnimationTriggers: + m_NormalTrigger: Normal + m_HighlightedTrigger: Highlighted + m_PressedTrigger: Pressed + m_SelectedTrigger: Selected + m_DisabledTrigger: Disabled + m_Interactable: 1 + m_TargetGraphic: {fileID: 2927271269830813759} + m_TextViewport: {fileID: 2927271268927848411} + m_TextComponent: {fileID: 2927271269316508806} + m_Placeholder: {fileID: 2927271268099144299} + m_VerticalScrollbar: {fileID: 0} + m_VerticalScrollbarEventHandler: {fileID: 0} + m_LayoutGroup: {fileID: 0} + m_ScrollSensitivity: 1 + m_ContentType: 0 + m_InputType: 0 + m_AsteriskChar: 42 + m_KeyboardType: 0 + m_LineType: 0 + m_HideMobileInput: 0 + m_HideSoftKeyboard: 0 + m_CharacterValidation: 0 + m_RegexValue: + m_GlobalPointSize: 14 + m_CharacterLimit: 0 + m_OnEndEdit: + m_PersistentCalls: + m_Calls: [] + m_OnSubmit: + m_PersistentCalls: + m_Calls: [] + m_OnSelect: + m_PersistentCalls: + m_Calls: [] + m_OnDeselect: + m_PersistentCalls: + m_Calls: [] + m_OnTextSelection: + m_PersistentCalls: + m_Calls: [] + m_OnEndTextSelection: + m_PersistentCalls: + m_Calls: [] + m_OnValueChanged: + m_PersistentCalls: + m_Calls: [] + m_OnTouchScreenKeyboardStatusChanged: + m_PersistentCalls: + m_Calls: [] + m_CaretColor: {r: 0.19607843, g: 0.19607843, b: 0.19607843, a: 1} + m_CustomCaretColor: 0 + m_SelectionColor: {r: 0.65882355, g: 0.80784315, b: 1, a: 0.7529412} + m_Text: 0 + m_CaretBlinkRate: 0.85 + m_CaretWidth: 1 + m_ReadOnly: 0 + m_RichText: 1 + m_GlobalFontAsset: {fileID: 11400000, guid: 8f586378b4e144a9851e7b34d9b748ee, type: 2} + m_OnFocusSelectAll: 1 + m_ResetOnDeActivation: 1 + m_RestoreOriginalTextOnEscape: 1 + m_isRichTextEditingAllowed: 0 + m_LineLimit: 0 + m_InputValidator: {fileID: 0} +--- !u!1 &2927271270070760194 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 2927271270070760197} + - component: {fileID: 2927271270070760196} + - component: {fileID: 2927271270070760199} + m_Layer: 5 + m_Name: ConfigInputVec3 + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &2927271270070760197 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271270070760194} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: + - {fileID: 2927271268904817446} + - {fileID: 2927271269163506454} + - {fileID: 2927271269114347238} + - {fileID: 2927271269830813757} + - {fileID: 2927271268761643352} + m_Father: {fileID: 0} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0.5, y: 1} + m_AnchorMax: {x: 0.5, y: 1} + m_AnchoredPosition: {x: -100, y: -250} + m_SizeDelta: {x: 320, y: 40} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!114 &2927271270070760196 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271270070760194} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: b6e1779348dcc2b48a6f009b828e9b5d, type: 3} + m_Name: + m_EditorClassIdentifier: + configTag: + allowInput: 1 + autoUpdateValue: 1 + allowBlockUpdate: 1 + forceBlockUpdate: 0 + numberFormat: 0.## + titleLabel: {fileID: 2927271269163506441} + titleTextContext: + helpLabel: {fileID: 2085812642091415763} + helpTextContext: + unitLabel: {fileID: 0} + unitTextContext: + autoUpdateValueToggle: {fileID: 2927271269017926700} + autoUpdateValueToggleReversalState: 0 + autoUpdateValueReversalState: 1 + dirtyAutoReset: 0 + editorInput: {x: 0, y: 0, z: 0} + targetInputX: {fileID: 2927271269114347237} + targetInputY: {fileID: 2927271269830813756} + targetInputZ: {fileID: 2927271268761643355} +--- !u!114 &2927271270070760199 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271270070760194} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 30649d3a9faa99c48a7b1166b86bf2a0, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Padding: + m_Left: 0 + m_Right: 0 + m_Top: 0 + m_Bottom: 0 + m_ChildAlignment: 3 + m_Spacing: 0 + m_ChildForceExpandWidth: 1 + m_ChildForceExpandHeight: 1 + m_ChildControlWidth: 0 + m_ChildControlHeight: 0 + m_ChildScaleWidth: 0 + m_ChildScaleHeight: 0 + m_ReverseArrangement: 0 +--- !u!1 &2927271270073750013 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 2927271270073750012} + - component: {fileID: 2927271270073750014} + - component: {fileID: 2927271270073750015} + m_Layer: 5 + m_Name: Text + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &2927271270073750012 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271270073750013} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: [] + m_Father: {fileID: 2927271268811268914} + m_RootOrder: 1 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 0, y: 0} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &2927271270073750014 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271270073750013} + m_CullTransparentMesh: 1 +--- !u!114 &2927271270073750015 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2927271270073750013} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: f4688fdb7df04437aeb418b961361dc5, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_text: "NAN\u200B" + m_isRightToLeft: 0 + m_fontAsset: {fileID: 11400000, guid: 713219d18e2f8c440b4e4435211afb23, type: 2} + m_sharedMaterial: {fileID: -1567122069935691074, guid: 713219d18e2f8c440b4e4435211afb23, type: 2} + m_fontSharedMaterials: [] + m_fontMaterial: {fileID: 0} + m_fontMaterials: [] + m_fontColor32: + serializedVersion: 2 + rgba: 4281479730 + m_fontColor: {r: 0.19607843, g: 0.19607843, b: 0.19607843, a: 1} + m_enableVertexGradient: 0 + m_colorMode: 3 + m_fontColorGradient: + topLeft: {r: 1, g: 1, b: 1, a: 1} + topRight: {r: 1, g: 1, b: 1, a: 1} + bottomLeft: {r: 1, g: 1, b: 1, a: 1} + bottomRight: {r: 1, g: 1, b: 1, a: 1} + m_fontColorGradientPreset: {fileID: 0} + m_spriteAsset: {fileID: 0} + m_tintAllSprites: 0 + m_StyleSheet: {fileID: 0} + m_TextStyleHashCode: -1183493901 + m_overrideHtmlColors: 0 + m_faceColor: + serializedVersion: 2 + rgba: 4294967295 + m_fontSize: 14 + m_fontSizeBase: 14 + m_fontWeight: 400 + m_enableAutoSizing: 0 + m_fontSizeMin: 18 + m_fontSizeMax: 72 + m_fontStyle: 0 + m_HorizontalAlignment: 2 + m_VerticalAlignment: 512 + m_textAlignment: 65535 + m_characterSpacing: 0 + m_wordSpacing: 0 + m_lineSpacing: 0 + m_lineSpacingMax: 0 + m_paragraphSpacing: 0 + m_charWidthMaxAdj: 0 + m_enableWordWrapping: 0 + m_wordWrappingRatios: 0.4 + m_overflowMode: 0 + m_linkedTextComponent: {fileID: 0} + parentLinkedComponent: {fileID: 0} + m_enableKerning: 1 + m_enableExtraPadding: 1 + checkPaddingRequired: 0 + m_isRichText: 1 + m_parseCtrlCharacters: 1 + m_isOrthographic: 1 + m_isCullingEnabled: 0 + m_horizontalMapping: 0 + m_verticalMapping: 0 + m_uvLineOffset: 0 + m_geometrySortingOrder: 0 + m_IsTextObjectScaleStatic: 0 + m_VertexBufferAutoSizeReduction: 0 + m_useMaxVisibleDescender: 1 + m_pageToDisplay: 1 + m_margin: {x: 0, y: 0, z: 0, w: 0} + m_isUsingLegacyAnimationComponent: 0 + m_isVolumetricText: 0 + m_hasFontAssetChanged: 0 + m_baseMaterial: {fileID: 0} + m_maskOffset: {x: 0, y: 0, z: 0, w: 0} +--- !u!1 &6648442917490892689 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 4508613349293898183} + - component: {fileID: 7357678653421707141} + - component: {fileID: 2085812642091415763} + m_Layer: 5 + m_Name: help + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &4508613349293898183 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 6648442917490892689} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: [] + m_Father: {fileID: 2927271269163506454} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 1} + m_AnchorMax: {x: 0, y: 1} + m_AnchoredPosition: {x: 0, y: -35} + m_SizeDelta: {x: 300, y: 50} + m_Pivot: {x: 0, y: 1} +--- !u!222 &7357678653421707141 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 6648442917490892689} + m_CullTransparentMesh: 1 +--- !u!114 &2085812642091415763 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 6648442917490892689} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: f4688fdb7df04437aeb418b961361dc5, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_text: + m_isRightToLeft: 0 + m_fontAsset: {fileID: 11400000, guid: 3bd21f304e77db54eb98a1f35f6a2680, type: 2} + m_sharedMaterial: {fileID: -3509209986637506031, guid: 3bd21f304e77db54eb98a1f35f6a2680, type: 2} + m_fontSharedMaterials: [] + m_fontMaterial: {fileID: 0} + m_fontMaterials: [] + m_fontColor32: + serializedVersion: 2 + rgba: 4278190335 + m_fontColor: {r: 1, g: 0, b: 0, a: 1} + m_enableVertexGradient: 0 + m_colorMode: 3 + m_fontColorGradient: + topLeft: {r: 1, g: 1, b: 1, a: 1} + topRight: {r: 1, g: 1, b: 1, a: 1} + bottomLeft: {r: 1, g: 1, b: 1, a: 1} + bottomRight: {r: 1, g: 1, b: 1, a: 1} + m_fontColorGradientPreset: {fileID: 0} + m_spriteAsset: {fileID: 0} + m_tintAllSprites: 0 + m_StyleSheet: {fileID: 0} + m_TextStyleHashCode: -1183493901 + m_overrideHtmlColors: 0 + m_faceColor: + serializedVersion: 2 + rgba: 4294967295 + m_fontSize: 14 + m_fontSizeBase: 14 + m_fontWeight: 400 + m_enableAutoSizing: 0 + m_fontSizeMin: 18 + m_fontSizeMax: 72 + m_fontStyle: 0 + m_HorizontalAlignment: 1 + m_VerticalAlignment: 256 + m_textAlignment: 65535 + m_characterSpacing: 0 + m_wordSpacing: 0 + m_lineSpacing: 0 + m_lineSpacingMax: 0 + m_paragraphSpacing: 0 + m_charWidthMaxAdj: 0 + m_enableWordWrapping: 1 + m_wordWrappingRatios: 0.4 + m_overflowMode: 0 + m_linkedTextComponent: {fileID: 0} + parentLinkedComponent: {fileID: 0} + m_enableKerning: 1 + m_enableExtraPadding: 0 + checkPaddingRequired: 0 + m_isRichText: 1 + m_parseCtrlCharacters: 1 + m_isOrthographic: 1 + m_isCullingEnabled: 0 + m_horizontalMapping: 0 + m_verticalMapping: 0 + m_uvLineOffset: 0 + m_geometrySortingOrder: 0 + m_IsTextObjectScaleStatic: 0 + m_VertexBufferAutoSizeReduction: 0 + m_useMaxVisibleDescender: 1 + m_pageToDisplay: 1 + m_margin: {x: 0, y: 0, z: 0, w: 0} + m_isUsingLegacyAnimationComponent: 0 + m_isVolumetricText: 0 + m_hasFontAssetChanged: 0 + m_baseMaterial: {fileID: 0} + m_maskOffset: {x: 0, y: 0, z: 0, w: 0} diff --git a/Resources/Prefab/ConfigUIItem/ConfigToggleGroup.prefab b/Resources/Prefab/ConfigUIItem/ConfigToggleGroup.prefab new file mode 100644 index 0000000..f5c0045 --- /dev/null +++ b/Resources/Prefab/ConfigUIItem/ConfigToggleGroup.prefab @@ -0,0 +1,1413 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!1 &2117159763 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 2117159764} + - component: {fileID: 2117159766} + - component: {fileID: 2117159765} + m_Layer: 5 + m_Name: help + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &2117159764 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2117159763} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: [] + m_Father: {fileID: 6174908271898150799} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 1} + m_AnchorMax: {x: 0, y: 1} + m_AnchoredPosition: {x: 0, y: -35} + m_SizeDelta: {x: 300, y: 50} + m_Pivot: {x: 0, y: 1} +--- !u!222 &2117159766 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2117159763} + m_CullTransparentMesh: 1 +--- !u!114 &2117159765 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2117159763} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: f4688fdb7df04437aeb418b961361dc5, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_text: + m_isRightToLeft: 0 + m_fontAsset: {fileID: 11400000, guid: 3bd21f304e77db54eb98a1f35f6a2680, type: 2} + m_sharedMaterial: {fileID: -3509209986637506031, guid: 3bd21f304e77db54eb98a1f35f6a2680, type: 2} + m_fontSharedMaterials: [] + m_fontMaterial: {fileID: 0} + m_fontMaterials: [] + m_fontColor32: + serializedVersion: 2 + rgba: 4278190335 + m_fontColor: {r: 1, g: 0, b: 0, a: 1} + m_enableVertexGradient: 0 + m_colorMode: 3 + m_fontColorGradient: + topLeft: {r: 1, g: 1, b: 1, a: 1} + topRight: {r: 1, g: 1, b: 1, a: 1} + bottomLeft: {r: 1, g: 1, b: 1, a: 1} + bottomRight: {r: 1, g: 1, b: 1, a: 1} + m_fontColorGradientPreset: {fileID: 0} + m_spriteAsset: {fileID: 0} + m_tintAllSprites: 0 + m_StyleSheet: {fileID: 0} + m_TextStyleHashCode: -1183493901 + m_overrideHtmlColors: 0 + m_faceColor: + serializedVersion: 2 + rgba: 4294967295 + m_fontSize: 14 + m_fontSizeBase: 14 + m_fontWeight: 400 + m_enableAutoSizing: 0 + m_fontSizeMin: 18 + m_fontSizeMax: 72 + m_fontStyle: 0 + m_HorizontalAlignment: 1 + m_VerticalAlignment: 256 + m_textAlignment: 65535 + m_characterSpacing: 0 + m_wordSpacing: 0 + m_lineSpacing: 0 + m_lineSpacingMax: 0 + m_paragraphSpacing: 0 + m_charWidthMaxAdj: 0 + m_enableWordWrapping: 1 + m_wordWrappingRatios: 0.4 + m_overflowMode: 0 + m_linkedTextComponent: {fileID: 0} + parentLinkedComponent: {fileID: 0} + m_enableKerning: 1 + m_enableExtraPadding: 0 + checkPaddingRequired: 0 + m_isRichText: 1 + m_parseCtrlCharacters: 1 + m_isOrthographic: 1 + m_isCullingEnabled: 0 + m_horizontalMapping: 0 + m_verticalMapping: 0 + m_uvLineOffset: 0 + m_geometrySortingOrder: 0 + m_IsTextObjectScaleStatic: 0 + m_VertexBufferAutoSizeReduction: 0 + m_useMaxVisibleDescender: 1 + m_pageToDisplay: 1 + m_margin: {x: 0, y: 0, z: 0, w: 0} + m_isUsingLegacyAnimationComponent: 0 + m_isVolumetricText: 0 + m_hasFontAssetChanged: 0 + m_baseMaterial: {fileID: 0} + m_maskOffset: {x: 0, y: 0, z: 0, w: 0} +--- !u!1 &123170061605424874 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 6686372413977617926} + - component: {fileID: 7477815931115001129} + - component: {fileID: 5066252649954232757} + m_Layer: 5 + m_Name: Text (TMP) (2) + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &6686372413977617926 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 123170061605424874} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: [] + m_Father: {fileID: 1439124241362632859} + m_RootOrder: 1 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0.5} + m_AnchorMax: {x: 0, y: 0.5} + m_AnchoredPosition: {x: 20, y: 0} + m_SizeDelta: {x: 40, y: 40} + m_Pivot: {x: 0, y: 0.5} +--- !u!222 &7477815931115001129 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 123170061605424874} + m_CullTransparentMesh: 1 +--- !u!114 &5066252649954232757 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 123170061605424874} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: f4688fdb7df04437aeb418b961361dc5, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_text: "\u5426" + m_isRightToLeft: 0 + m_fontAsset: {fileID: 11400000, guid: 3bd21f304e77db54eb98a1f35f6a2680, type: 2} + m_sharedMaterial: {fileID: -3509209986637506031, guid: 3bd21f304e77db54eb98a1f35f6a2680, type: 2} + m_fontSharedMaterials: [] + m_fontMaterial: {fileID: 0} + m_fontMaterials: [] + m_fontColor32: + serializedVersion: 2 + rgba: 4278190080 + m_fontColor: {r: 0, g: 0, b: 0, a: 1} + m_enableVertexGradient: 0 + m_colorMode: 3 + m_fontColorGradient: + topLeft: {r: 1, g: 1, b: 1, a: 1} + topRight: {r: 1, g: 1, b: 1, a: 1} + bottomLeft: {r: 1, g: 1, b: 1, a: 1} + bottomRight: {r: 1, g: 1, b: 1, a: 1} + m_fontColorGradientPreset: {fileID: 0} + m_spriteAsset: {fileID: 0} + m_tintAllSprites: 0 + m_StyleSheet: {fileID: 0} + m_TextStyleHashCode: -1183493901 + m_overrideHtmlColors: 0 + m_faceColor: + serializedVersion: 2 + rgba: 4294967295 + m_fontSize: 17 + m_fontSizeBase: 17 + m_fontWeight: 400 + m_enableAutoSizing: 0 + m_fontSizeMin: 18 + m_fontSizeMax: 72 + m_fontStyle: 0 + m_HorizontalAlignment: 2 + m_VerticalAlignment: 512 + m_textAlignment: 65535 + m_characterSpacing: 0 + m_wordSpacing: 0 + m_lineSpacing: 0 + m_lineSpacingMax: 0 + m_paragraphSpacing: 0 + m_charWidthMaxAdj: 0 + m_enableWordWrapping: 1 + m_wordWrappingRatios: 0.4 + m_overflowMode: 0 + m_linkedTextComponent: {fileID: 0} + parentLinkedComponent: {fileID: 0} + m_enableKerning: 1 + m_enableExtraPadding: 0 + checkPaddingRequired: 0 + m_isRichText: 1 + m_parseCtrlCharacters: 1 + m_isOrthographic: 1 + m_isCullingEnabled: 0 + m_horizontalMapping: 0 + m_verticalMapping: 0 + m_uvLineOffset: 0 + m_geometrySortingOrder: 0 + m_IsTextObjectScaleStatic: 0 + m_VertexBufferAutoSizeReduction: 0 + m_useMaxVisibleDescender: 1 + m_pageToDisplay: 1 + m_margin: {x: 0, y: -1.5838165, z: 0, w: 0} + m_isUsingLegacyAnimationComponent: 0 + m_isVolumetricText: 0 + m_hasFontAssetChanged: 0 + m_baseMaterial: {fileID: 0} + m_maskOffset: {x: 0, y: 0, z: 0, w: 0} +--- !u!1 &1677664047476404575 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 1677664047476404568} + - component: {fileID: 1677664047476404570} + - component: {fileID: 1677664047476404569} + m_Layer: 5 + m_Name: Checkmark + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &1677664047476404568 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1677664047476404575} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: [] + m_Father: {fileID: 1677664048684071378} + m_RootOrder: 1 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: -0.00000014901161, y: 0.00000013579847} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &1677664047476404570 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1677664047476404575} + m_CullTransparentMesh: 1 +--- !u!114 &1677664047476404569 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1677664047476404575} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_Sprite: {fileID: 21300000, guid: 1f2a868175c8a8a47a887eea9056fe28, type: 3} + m_Type: 0 + m_PreserveAspect: 0 + m_FillCenter: 1 + m_FillMethod: 4 + m_FillAmount: 1 + m_FillClockwise: 1 + m_FillOrigin: 0 + m_UseSpriteMesh: 0 + m_PixelsPerUnitMultiplier: 1 +--- !u!1 &1677664048594651646 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 1677664048594651647} + m_Layer: 5 + m_Name: toggle + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &1677664048594651647 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1677664048594651646} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: + - {fileID: 1677664048684071378} + m_Father: {fileID: 7086089555640883732} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 0, y: 0} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 22, y: 40} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!1 &1677664048684071377 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 1677664048684071378} + - component: {fileID: 1677664048684071379} + m_Layer: 5 + m_Name: Toggle + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &1677664048684071378 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1677664048684071377} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: + - {fileID: 1677664048784848821} + - {fileID: 1677664047476404568} + m_Father: {fileID: 1677664048594651647} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0.5} + m_AnchorMax: {x: 0, y: 0.5} + m_AnchoredPosition: {x: 0, y: -0.000015258789} + m_SizeDelta: {x: 16, y: 16} + m_Pivot: {x: 0, y: 0.5} +--- !u!114 &1677664048684071379 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1677664048684071377} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 9085046f02f69544eb97fd06b6048fe2, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Navigation: + m_Mode: 3 + m_WrapAround: 0 + m_SelectOnUp: {fileID: 0} + m_SelectOnDown: {fileID: 0} + m_SelectOnLeft: {fileID: 0} + m_SelectOnRight: {fileID: 0} + m_Transition: 1 + m_Colors: + m_NormalColor: {r: 1, g: 1, b: 1, a: 1} + m_HighlightedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} + m_PressedColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 1} + m_SelectedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} + m_DisabledColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 0.5019608} + m_ColorMultiplier: 1 + m_FadeDuration: 0.1 + m_SpriteState: + m_HighlightedSprite: {fileID: 0} + m_PressedSprite: {fileID: 0} + m_SelectedSprite: {fileID: 0} + m_DisabledSprite: {fileID: 0} + m_AnimationTriggers: + m_NormalTrigger: Normal + m_HighlightedTrigger: Highlighted + m_PressedTrigger: Pressed + m_SelectedTrigger: Selected + m_DisabledTrigger: Disabled + m_Interactable: 1 + m_TargetGraphic: {fileID: 1677664048784848822} + toggleTransition: 1 + graphic: {fileID: 1677664047476404569} + m_Group: {fileID: 0} + onValueChanged: + m_PersistentCalls: + m_Calls: [] + m_IsOn: 0 +--- !u!1 &1677664048784848820 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 1677664048784848821} + - component: {fileID: 1677664048784848823} + - component: {fileID: 1677664048784848822} + m_Layer: 5 + m_Name: Background + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &1677664048784848821 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1677664048784848820} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: [] + m_Father: {fileID: 1677664048684071378} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0.03426361, y: 0.00049591064} + m_SizeDelta: {x: 0.065603256, y: 0.00012207031} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &1677664048784848823 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1677664048784848820} + m_CullTransparentMesh: 1 +--- !u!114 &1677664048784848822 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1677664048784848820} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_Sprite: {fileID: 21300000, guid: 56a95a2d9d13e774093a51bcbebb8e7f, type: 3} + m_Type: 0 + m_PreserveAspect: 0 + m_FillCenter: 1 + m_FillMethod: 4 + m_FillAmount: 1 + m_FillClockwise: 1 + m_FillOrigin: 0 + m_UseSpriteMesh: 0 + m_PixelsPerUnitMultiplier: 1 +--- !u!1 &2976506938642487095 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 7086089555640883732} + - component: {fileID: 8583024567832070072} + - component: {fileID: 7086089555640883733} + - component: {fileID: 7086089555640883734} + m_Layer: 5 + m_Name: ConfigToggleGroup + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &7086089555640883732 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2976506938642487095} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: + - {fileID: 1677664048594651647} + - {fileID: 6174908271898150799} + - {fileID: 5066042018155965668} + - {fileID: 1439124241362632859} + m_Father: {fileID: 0} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0.5, y: 1} + m_AnchorMax: {x: 0.5, y: 1} + m_AnchoredPosition: {x: -100, y: -200} + m_SizeDelta: {x: 320, y: 40} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!114 &8583024567832070072 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2976506938642487095} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 2fafe2cfe61f6974895a912c3755e8f1, type: 3} + m_Name: + m_EditorClassIdentifier: + m_AllowSwitchOff: 0 +--- !u!114 &7086089555640883733 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2976506938642487095} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 1b1b61fd3a211734eb3d51cedcbe579f, type: 3} + m_Name: + m_EditorClassIdentifier: + configTag: + allowInput: 1 + autoUpdateValue: 1 + allowBlockUpdate: 1 + forceBlockUpdate: 0 + numberFormat: 0.## + titleLabel: {fileID: 8096507953901690736} + titleTextContext: + helpLabel: {fileID: 2117159765} + helpTextContext: + unitLabel: {fileID: 0} + unitTextContext: + autoUpdateValueToggle: {fileID: 1677664048684071379} + autoUpdateValueToggleReversalState: 0 + autoUpdateValueReversalState: 1 + dirtyAutoReset: 0 + targetToggle: {fileID: 8583024567832070072} + toggles: + - {fileID: 7547216229149869176} + - {fileID: 424388523580469770} +--- !u!114 &7086089555640883734 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2976506938642487095} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 30649d3a9faa99c48a7b1166b86bf2a0, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Padding: + m_Left: 0 + m_Right: 0 + m_Top: 0 + m_Bottom: 0 + m_ChildAlignment: 3 + m_Spacing: 0 + m_ChildForceExpandWidth: 1 + m_ChildForceExpandHeight: 1 + m_ChildControlWidth: 0 + m_ChildControlHeight: 0 + m_ChildScaleWidth: 0 + m_ChildScaleHeight: 0 + m_ReverseArrangement: 0 +--- !u!1 &2992747000675469797 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 7234410082609919438} + - component: {fileID: 511671251547521328} + - component: {fileID: 961132754790981913} + m_Layer: 5 + m_Name: Background + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &7234410082609919438 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2992747000675469797} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: + - {fileID: 4673320512658182920} + m_Father: {fileID: 1439124241362632859} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0.5} + m_AnchorMax: {x: 0, y: 0.5} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 20, y: 20} + m_Pivot: {x: 0, y: 0.5} +--- !u!222 &511671251547521328 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2992747000675469797} + m_CullTransparentMesh: 1 +--- !u!114 &961132754790981913 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2992747000675469797} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_Sprite: {fileID: 21300000, guid: 4845104f386f9ec40b1f47a805a89f90, type: 3} + m_Type: 0 + m_PreserveAspect: 0 + m_FillCenter: 1 + m_FillMethod: 4 + m_FillAmount: 1 + m_FillClockwise: 1 + m_FillOrigin: 0 + m_UseSpriteMesh: 0 + m_PixelsPerUnitMultiplier: 1 +--- !u!1 &3998200964024397844 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 4673320512658182920} + - component: {fileID: 3703304898224328538} + - component: {fileID: 2296093603202879498} + m_Layer: 5 + m_Name: Checkmark + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &4673320512658182920 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 3998200964024397844} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: [] + m_Father: {fileID: 7234410082609919438} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0.5, y: 0.5} + m_AnchorMax: {x: 0.5, y: 0.5} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 20, y: 20} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &3703304898224328538 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 3998200964024397844} + m_CullTransparentMesh: 1 +--- !u!114 &2296093603202879498 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 3998200964024397844} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_Sprite: {fileID: 21300000, guid: 5fbdc8ff976bcfa42a530660e2206162, type: 3} + m_Type: 0 + m_PreserveAspect: 0 + m_FillCenter: 1 + m_FillMethod: 4 + m_FillAmount: 1 + m_FillClockwise: 1 + m_FillOrigin: 0 + m_UseSpriteMesh: 0 + m_PixelsPerUnitMultiplier: 1 +--- !u!1 &4350024691618424406 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 6181777852424775480} + - component: {fileID: 1181337417027782414} + - component: {fileID: 4133755363146329968} + m_Layer: 5 + m_Name: Background + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &6181777852424775480 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4350024691618424406} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: + - {fileID: 1727419857374572296} + m_Father: {fileID: 5066042018155965668} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0.5} + m_AnchorMax: {x: 0, y: 0.5} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 20, y: 20} + m_Pivot: {x: 0, y: 0.5} +--- !u!222 &1181337417027782414 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4350024691618424406} + m_CullTransparentMesh: 1 +--- !u!114 &4133755363146329968 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 4350024691618424406} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_Sprite: {fileID: 21300000, guid: 4845104f386f9ec40b1f47a805a89f90, type: 3} + m_Type: 0 + m_PreserveAspect: 0 + m_FillCenter: 1 + m_FillMethod: 4 + m_FillAmount: 1 + m_FillClockwise: 1 + m_FillOrigin: 0 + m_UseSpriteMesh: 0 + m_PixelsPerUnitMultiplier: 1 +--- !u!1 &5670447386526982952 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 1727419857374572296} + - component: {fileID: 1481669761061207115} + - component: {fileID: 7535530090186065753} + m_Layer: 5 + m_Name: Checkmark + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &1727419857374572296 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 5670447386526982952} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: [] + m_Father: {fileID: 6181777852424775480} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0.5, y: 0.5} + m_AnchorMax: {x: 0.5, y: 0.5} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 20, y: 20} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &1481669761061207115 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 5670447386526982952} + m_CullTransparentMesh: 1 +--- !u!114 &7535530090186065753 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 5670447386526982952} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_Sprite: {fileID: 21300000, guid: 5fbdc8ff976bcfa42a530660e2206162, type: 3} + m_Type: 0 + m_PreserveAspect: 0 + m_FillCenter: 1 + m_FillMethod: 4 + m_FillAmount: 1 + m_FillClockwise: 1 + m_FillOrigin: 0 + m_UseSpriteMesh: 0 + m_PixelsPerUnitMultiplier: 1 +--- !u!1 &5858350584026605194 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 6892980073193010597} + - component: {fileID: 779170056630877938} + - component: {fileID: 4979884104386161715} + m_Layer: 5 + m_Name: Text (TMP) (2) + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &6892980073193010597 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 5858350584026605194} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: [] + m_Father: {fileID: 5066042018155965668} + m_RootOrder: 1 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0.5} + m_AnchorMax: {x: 0, y: 0.5} + m_AnchoredPosition: {x: 20, y: 0} + m_SizeDelta: {x: 40, y: 40} + m_Pivot: {x: 0, y: 0.5} +--- !u!222 &779170056630877938 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 5858350584026605194} + m_CullTransparentMesh: 1 +--- !u!114 &4979884104386161715 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 5858350584026605194} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: f4688fdb7df04437aeb418b961361dc5, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_text: "\u662F" + m_isRightToLeft: 0 + m_fontAsset: {fileID: 11400000, guid: 3bd21f304e77db54eb98a1f35f6a2680, type: 2} + m_sharedMaterial: {fileID: -3509209986637506031, guid: 3bd21f304e77db54eb98a1f35f6a2680, type: 2} + m_fontSharedMaterials: [] + m_fontMaterial: {fileID: 0} + m_fontMaterials: [] + m_fontColor32: + serializedVersion: 2 + rgba: 4278190080 + m_fontColor: {r: 0, g: 0, b: 0, a: 1} + m_enableVertexGradient: 0 + m_colorMode: 3 + m_fontColorGradient: + topLeft: {r: 1, g: 1, b: 1, a: 1} + topRight: {r: 1, g: 1, b: 1, a: 1} + bottomLeft: {r: 1, g: 1, b: 1, a: 1} + bottomRight: {r: 1, g: 1, b: 1, a: 1} + m_fontColorGradientPreset: {fileID: 0} + m_spriteAsset: {fileID: 0} + m_tintAllSprites: 0 + m_StyleSheet: {fileID: 0} + m_TextStyleHashCode: -1183493901 + m_overrideHtmlColors: 0 + m_faceColor: + serializedVersion: 2 + rgba: 4294967295 + m_fontSize: 17 + m_fontSizeBase: 17 + m_fontWeight: 400 + m_enableAutoSizing: 0 + m_fontSizeMin: 18 + m_fontSizeMax: 72 + m_fontStyle: 0 + m_HorizontalAlignment: 2 + m_VerticalAlignment: 512 + m_textAlignment: 65535 + m_characterSpacing: 0 + m_wordSpacing: 0 + m_lineSpacing: 0 + m_lineSpacingMax: 0 + m_paragraphSpacing: 0 + m_charWidthMaxAdj: 0 + m_enableWordWrapping: 1 + m_wordWrappingRatios: 0.4 + m_overflowMode: 0 + m_linkedTextComponent: {fileID: 0} + parentLinkedComponent: {fileID: 0} + m_enableKerning: 1 + m_enableExtraPadding: 0 + checkPaddingRequired: 0 + m_isRichText: 1 + m_parseCtrlCharacters: 1 + m_isOrthographic: 1 + m_isCullingEnabled: 0 + m_horizontalMapping: 0 + m_verticalMapping: 0 + m_uvLineOffset: 0 + m_geometrySortingOrder: 0 + m_IsTextObjectScaleStatic: 0 + m_VertexBufferAutoSizeReduction: 0 + m_useMaxVisibleDescender: 1 + m_pageToDisplay: 1 + m_margin: {x: 0, y: -1.5838165, z: 0, w: 0} + m_isUsingLegacyAnimationComponent: 0 + m_isVolumetricText: 0 + m_hasFontAssetChanged: 0 + m_baseMaterial: {fileID: 0} + m_maskOffset: {x: 0, y: 0, z: 0, w: 0} +--- !u!1 &6744662161718396355 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 1439124241362632859} + - component: {fileID: 7547216229149869176} + m_Layer: 5 + m_Name: no + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &1439124241362632859 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 6744662161718396355} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: + - {fileID: 7234410082609919438} + - {fileID: 6686372413977617926} + m_Father: {fileID: 7086089555640883732} + m_RootOrder: 3 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 0, y: 0} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 90, y: 40} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!114 &7547216229149869176 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 6744662161718396355} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 9085046f02f69544eb97fd06b6048fe2, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Navigation: + m_Mode: 3 + m_WrapAround: 0 + m_SelectOnUp: {fileID: 0} + m_SelectOnDown: {fileID: 0} + m_SelectOnLeft: {fileID: 0} + m_SelectOnRight: {fileID: 0} + m_Transition: 1 + m_Colors: + m_NormalColor: {r: 1, g: 1, b: 1, a: 1} + m_HighlightedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} + m_PressedColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 1} + m_SelectedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} + m_DisabledColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 0.5019608} + m_ColorMultiplier: 1 + m_FadeDuration: 0.1 + m_SpriteState: + m_HighlightedSprite: {fileID: 0} + m_PressedSprite: {fileID: 0} + m_SelectedSprite: {fileID: 0} + m_DisabledSprite: {fileID: 0} + m_AnimationTriggers: + m_NormalTrigger: Normal + m_HighlightedTrigger: Highlighted + m_PressedTrigger: Pressed + m_SelectedTrigger: Selected + m_DisabledTrigger: Disabled + m_Interactable: 1 + m_TargetGraphic: {fileID: 961132754790981913} + toggleTransition: 1 + graphic: {fileID: 2296093603202879498} + m_Group: {fileID: 8583024567832070072} + onValueChanged: + m_PersistentCalls: + m_Calls: [] + m_IsOn: 1 +--- !u!1 &7286992859838293554 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 6174908271898150799} + - component: {fileID: 245253317301007010} + - component: {fileID: 8096507953901690736} + m_Layer: 5 + m_Name: title + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &6174908271898150799 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 7286992859838293554} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: + - {fileID: 2117159764} + m_Father: {fileID: 7086089555640883732} + m_RootOrder: 1 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 0, y: 0} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 120, y: 40} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &245253317301007010 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 7286992859838293554} + m_CullTransparentMesh: 1 +--- !u!114 &8096507953901690736 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 7286992859838293554} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: f4688fdb7df04437aeb418b961361dc5, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_text: + m_isRightToLeft: 0 + m_fontAsset: {fileID: 11400000, guid: 3bd21f304e77db54eb98a1f35f6a2680, type: 2} + m_sharedMaterial: {fileID: -3509209986637506031, guid: 3bd21f304e77db54eb98a1f35f6a2680, type: 2} + m_fontSharedMaterials: [] + m_fontMaterial: {fileID: 0} + m_fontMaterials: [] + m_fontColor32: + serializedVersion: 2 + rgba: 4278190080 + m_fontColor: {r: 0, g: 0, b: 0, a: 1} + m_enableVertexGradient: 0 + m_colorMode: 3 + m_fontColorGradient: + topLeft: {r: 1, g: 1, b: 1, a: 1} + topRight: {r: 1, g: 1, b: 1, a: 1} + bottomLeft: {r: 1, g: 1, b: 1, a: 1} + bottomRight: {r: 1, g: 1, b: 1, a: 1} + m_fontColorGradientPreset: {fileID: 0} + m_spriteAsset: {fileID: 0} + m_tintAllSprites: 0 + m_StyleSheet: {fileID: 0} + m_TextStyleHashCode: -1183493901 + m_overrideHtmlColors: 0 + m_faceColor: + serializedVersion: 2 + rgba: 4294967295 + m_fontSize: 16 + m_fontSizeBase: 16 + m_fontWeight: 400 + m_enableAutoSizing: 0 + m_fontSizeMin: 18 + m_fontSizeMax: 72 + m_fontStyle: 0 + m_HorizontalAlignment: 1 + m_VerticalAlignment: 512 + m_textAlignment: 65535 + m_characterSpacing: 0 + m_wordSpacing: 0 + m_lineSpacing: 0 + m_lineSpacingMax: 0 + m_paragraphSpacing: 0 + m_charWidthMaxAdj: 0 + m_enableWordWrapping: 1 + m_wordWrappingRatios: 0.4 + m_overflowMode: 0 + m_linkedTextComponent: {fileID: 0} + parentLinkedComponent: {fileID: 0} + m_enableKerning: 1 + m_enableExtraPadding: 0 + checkPaddingRequired: 0 + m_isRichText: 1 + m_parseCtrlCharacters: 1 + m_isOrthographic: 1 + m_isCullingEnabled: 0 + m_horizontalMapping: 0 + m_verticalMapping: 0 + m_uvLineOffset: 0 + m_geometrySortingOrder: 0 + m_IsTextObjectScaleStatic: 0 + m_VertexBufferAutoSizeReduction: 0 + m_useMaxVisibleDescender: 1 + m_pageToDisplay: 1 + m_margin: {x: 0, y: -1.5838165, z: 0, w: 0} + m_isUsingLegacyAnimationComponent: 0 + m_isVolumetricText: 0 + m_hasFontAssetChanged: 0 + m_baseMaterial: {fileID: 0} + m_maskOffset: {x: 0, y: 0, z: 0, w: 0} +--- !u!1 &7621251160999960232 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 5066042018155965668} + - component: {fileID: 424388523580469770} + m_Layer: 5 + m_Name: yes + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &5066042018155965668 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 7621251160999960232} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_ConstrainProportionsScale: 0 + m_Children: + - {fileID: 6181777852424775480} + - {fileID: 6892980073193010597} + m_Father: {fileID: 7086089555640883732} + m_RootOrder: 2 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 0, y: 0} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 90, y: 40} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!114 &424388523580469770 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 7621251160999960232} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 9085046f02f69544eb97fd06b6048fe2, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Navigation: + m_Mode: 3 + m_WrapAround: 0 + m_SelectOnUp: {fileID: 0} + m_SelectOnDown: {fileID: 0} + m_SelectOnLeft: {fileID: 0} + m_SelectOnRight: {fileID: 0} + m_Transition: 1 + m_Colors: + m_NormalColor: {r: 1, g: 1, b: 1, a: 1} + m_HighlightedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} + m_PressedColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 1} + m_SelectedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} + m_DisabledColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 0.5019608} + m_ColorMultiplier: 1 + m_FadeDuration: 0.1 + m_SpriteState: + m_HighlightedSprite: {fileID: 0} + m_PressedSprite: {fileID: 0} + m_SelectedSprite: {fileID: 0} + m_DisabledSprite: {fileID: 0} + m_AnimationTriggers: + m_NormalTrigger: Normal + m_HighlightedTrigger: Highlighted + m_PressedTrigger: Pressed + m_SelectedTrigger: Selected + m_DisabledTrigger: Disabled + m_Interactable: 1 + m_TargetGraphic: {fileID: 4133755363146329968} + toggleTransition: 1 + graphic: {fileID: 7535530090186065753} + m_Group: {fileID: 8583024567832070072} + onValueChanged: + m_PersistentCalls: + m_Calls: [] + m_IsOn: 0 diff --git a/Resources/Sprite/EnptyAlphaMask.png b/Resources/Sprite/EnptyAlphaMask.png new file mode 100644 index 0000000000000000000000000000000000000000..39c07a09a37d43d8954bccd823fee00c7fdccfdf GIT binary patch literal 102 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 G`~LuZoI{2H literal 0 HcmV?d00001 diff --git a/Resources/Sprite/arrow/downArrow.png b/Resources/Sprite/arrow/downArrow.png new file mode 100644 index 0000000000000000000000000000000000000000..fc02c405b5f1d44f5c0119db4137aee433b08158 GIT binary patch literal 281 zcmeAS@N?(olHy`uVBq!ia0vp^8X(NU1|)m_?Z^dEoCO|{#S9E$svykh8Km+7D0te_ z#W5tJ_3e#~g3Sg3EC-HH-N{m(WMwdS70c8DzJR2jIFIjA);nhZ^eNu&z;Kx9z(33F z@yt8YTV16d57b}t49KNG&Znu z95!^|muyRJ44-&-2S)<8=fgz}rYgPNEK=Xf%MbmVxY6yaUc`6pHR9J=W*xe0+KoA7r!B~JL*@-2972H{Z6;i_4!TKORXav38 zo%J4W5<)_9lMj}JpFu>>a(4d)d`kyf(}C7R07n1?zzpD6y;?+=Tawq5+79LwOaQXA zgaur~U8|b{#`;Xw^fit12D;-sffSq*3?lsxt0^65O$SPe)>Ww1E8Wc!axa>~av<&8 z%li%akq0uw45au!B&8ia!)JWj$H$bR>U!h#6!+ujPaB7PkdwS*yd|{3Xi0g2d}|L6 zzoQ%X6A!mek(0N$Bqx1aw_<|N0+y3(mnL#OP=8{^y`fcSukESxYeROHz0VW0-FxT8 zqt`sqcMiRsw{K-(j)LrQ7Ow)G1w6+Yyb1#s$cQuY9jt6TTo9Ka*~)B@UTC&idf{@p x$(`Jk$`V^x~>>n40tGY81l}`|{tW z3#K>bux*k&k)|-aF~{qHn4qMfu2R@dErz3&kM69yvF^~x2~#aNH%YlGU)`~{*qrqT zuS46K1D+E@EhIMysXK-}e$gvwk(DjBZu`zYhS?I|IcF*#&^ZvRc$?!x;hz}{W{U4* xXCB`fU%Q>5ZuUZ>31=P5m~Zl=7*BZ1>gKm7(Pd-WF`&a4JYD@<);T3K0RYPoUXTC) literal 0 HcmV?d00001 diff --git a/Runtime/AGV/Scripts/AGVSettingsManager.cs b/Runtime/AGV/Scripts/AGVSettingsManager.cs new file mode 100644 index 0000000..855dcb3 --- /dev/null +++ b/Runtime/AGV/Scripts/AGVSettingsManager.cs @@ -0,0 +1,21 @@ +using System.Collections; +using System.Collections.Generic; +using UnityEngine; + +namespace SesothoLine +{ + public class AGVSettingsManager : MonoBehaviour + { + // Start is called before the first frame update + void Start() + { + + } + + // Update is called once per frame + void Update() + { + + } + } +} diff --git a/Runtime/Deconstruction.xml b/Runtime/Deconstruction.xml new file mode 100644 index 0000000..fdb883c --- /dev/null +++ b/Runtime/Deconstruction.xml @@ -0,0 +1,3410 @@ + + + + Deconstruction + + + + + 链路接触点 + + 此框架默认不实现空间坐标的功能，需要后续类实现。 + + 链路接触点用于定义多个物体间的链路结构 + + + + + + 链路数据结构 + + + + + 获取此点在给定线上的法向 + + 注意：这里假定点一定在线的某一端上，所以并不会检查是否相连 + + + + + + + + 获取此点在给定线上的法向 + + 注意：这里假定点一定在线的某一端上，所以并不会检查是否相连 + + + + + + + + 安全地获取此点在给定线上的法向 + + + + + + + + + 安全地获取此点在给定线上的法向 + + + + + + + + + 基本可放置元素 + + 元素中不定义点或法向，后续通过接口实现，目的是为了区分所有的元素。 + 放置元素中需要实现与工具类相关的内容 + + + + + + 放置元素的销毁事件 + + + + + 所有放置元素的唯一标识符，可以用于序列化时引用查找 + + + + + 网格索引，如果成员添加到网格中进行了管理，那么持有这个索引会比较高效。 + + + + + 获取元素的计算边界 + + + + + + 获取元素到向上平面的边界 + + + + + + 显示调试信息 + + + + + 代理更新 + + 这是主线程方法，可以在此进行主要的数据交换操作 + + + + + + 代理更新 + + 这是主线程方法，可以在此进行主要的数据交换操作 + + + + + + 代理后置更新 + + 这是主线程方法，可以在此进行主要的数据交换操作 + + + + + + 代理异步更新之前 + + 这是主线程操作 + + + + + + 代理异步更新 + + 这是异步操作 + + + + + + 代理异步更新之后 + + 这是主线程操作 + + + + + + 当启用代理异步更新时 + + + + + 当从异步代理中退出时 + + + + + 通过反射检查当前实例是否实现了更新函数 + + + + + + 检查所有更新函数 + + + + + + 获取此放置元素的基础代理控制器 + + + + + + 驱使线运行的框架 + + 此框架使用2维计算器，但自身并不保存线的参数。 + + 需要后续类通过SetRenderer额外指定一个渲染器； + 且能够传递计算所需的参数，并调用UpdateRender完成渲染更新。 + + + + + + 渲染线段时获取点的默认步骤长度 + + 1r ≈ 1unity + 注意这是约等于，所以其实不算准确。 + + + + + + 轨迹渲染器 + + + + + 轨迹计算器 + + + + + 链路数据结构 + + + + + 当前的轨迹计算器 + + + + + 当前的轨迹渲染器 + + + + + 弧线计算器 + + + + + 直线计算器 + + + + + 轨迹计算器有效 + + + + + 当前选择使用圆弧计算器 + + + + + 二维线段参数 + + + + + 线段点A + + + + + 线段点B + + + + + 线段点A控制柄 + + + + + 线段点B控制柄 + + + + + 点A控制柄有效 + + + + + 点B控制柄有效 + + + + + 设置值 + + + + + + + + + 选择轨迹计算器枚举 + + + + + 圆弧 + + + + + 直线 + + + + + 初始化轨迹计算 + + + + + 绘制曲线 + + + + + 绘制直线 + + + + + 自动绘制线，根据输入的参数切换直线或曲线绘制。 + + 线参数 + 约束角，指定当前绘制的圆弧必须为一个特定度数 + 延起点法向绘制完整圆弧，否则只绘制半圆弧 + + + + 设置渲染组件 + + + + + + 更新渲染，将当前计算器结果设置到渲染中 + + + + + 分割线 + + + + + 初始化路径线 + + 提供一个用于绘制的组件 + + + + + 建筑物基类（建筑概要） + + + + + 一根线基本的绘制框架，提供基于线渲染器的绘制管理 + + 默认只支持等宽线绘制。 + + + + + + + + + + + 渲染线的线渲染器。 + + + + + 线条宽度 + + + + + 获取材质 + + + + + 线亮度 + + + + + 动画时间 + + + + + 箭头压缩程度 + + + + + 箭头穿插程度 + + + + + 反转箭头 + + + + + 箭头宽度占用比例 + + + + + 背景不透明度 + + + + + 背景色 + + + + + 前景色 + + + + + 线计算长度，用于更新显示的长度 + + + + + 角倒角数量 + + + + + 端点倒角数量 + + + + + 使用世界空间坐标 + + + + + 启用渲染 + + + + + 创建线渲染器，默认是本地空间 + + + + + 设置线渲染器上给定索引的一点 + + + + + + + 设置线渲染器上渲染的所有点（默认将长度限制在给定的范围内） + + + + + + + 将本地坐标转换到世界坐标空间 + + + + + 将世界坐标转换到本地坐标空间 + + + + + 一个拥有具有相连结构的对象所实现的接口，允许获取其中的相连数据结构 + + 其中LinkedData应该指向实现此接口类本地上的一个实现ICoterminous的实例字段 + + + + + + 链接数据 + + + + + 链接数据 + + + + + 将一个成员以指定的链路类型添加到结构中，相应地在对方成员中添加与之对立的结构 + + + + + + 将一个成员从中移除，相应地在对方成员中也移除此对立的结构 + + + + + + + 具有相连的结构数据目标 + + 对目标结构使用Add，与Remove可以添加链接关系 + 通常，具有链接关系的成员都会互相关联，所以可以使用Polarity方式进行添加与移除。 + 链接关系管理允许像链表一样遍历与维护对象，且不用在乎其中的成员类型。 + 另外链接的具体实现与当前成员的特性有关，需要根据具体成员特性进行使用 + + + + + + 将一个成员以指定的链路类型添加到结构中 + + + + + + + + 将一个成员从中移除 + + + + + + 移除所有具有给定链路类型的成员 + + + + + + 将一个成员从中移除，连同移除其反引用 + + + + + + 移除所有具有给定链路类型的成员，连同移除其反引用 + + + + + + 检查一个成员是否存在于结构中 + + + + + + + 获取与之对立的结构(如果有多个，那么会返回第一个) + + 如果没找到，返回空 + + + + 获取与之相同的结构(如果有多个，那么会返回第一个) + + + 如果没找到，返回空 + + + + 获取与给定链接成员对立的结构 + + + + + + + 获取与给定链接成员相同的结构 + + + + + + + 获取与此对立的所有结构 + + 如果没找到，返回空 + + + + 获取与之相同的所有结构 + + + + + + + 获取所有与给定链接成员对立的结构 + + + + + + + 获取所有与给定链接成员相同的结构 + + + + + + + 获取所有结构的数量 + + 返回的是所有有效的成员数量 + + + + + + + 清空结构 + + + + + 清空结构，连同其反引用 + + + + + 交换所有的命令方向 + + 只改变在结构中保存的命令结构方向，不改变数据 + + + + + + 控制对象是否进行调试绘制 + + + + + 是否启用调试绘制（用于可以主动绘制的对象） + + + + + 调试绘制的具体行为（用于无法主动绘制的对象） + + 用于无法自主绘制对象提供的被动绘制方法。 + + + + + + 切割线 + + + + + 获取在指定百分比处分割的轨迹 + + + + + + + + 允许实现此接口的成员被异步更新处理。 + + + + + 异步更新时的优先级，根据优先级进行穿插更新。 + (优先级0 -> oo数值越大优先级越低) + + + + + 由外部管理器协程控制的更新事件 + + 距离上次此成员被更新的时间 + + + + + 由外部管理器异步控制的更新事件 + (请确保其中没有会导致主线程异常的操作) + + + + + + 此处持有的轨迹相关成员，将其开放用于外部快捷获取 + + 所有包含轨迹计算的可放置对象都应该实现此接口，如果是建筑物可以实现另类的渲染器结构。 + 一个可放置对象拥有轨迹接口将代表其拥有轨迹计算的一切必备条件。 + + 注意，其中的三维空间是转为平面向上，二维则是标准xy竖直平面进行变换，两者都会根据当前的物体位置进行变换。 + + + + + + 轨迹渲染器 + + + + + 轨迹计算器 + + + + + 获取此轨迹的点位迭代器，并根据当前实现需求转为水平面世界空间。 + + 迭代步长，1点步长相当于unity中的1m + + + + + 获取此轨迹的点位迭代器，并根据当前实现需求转为立面世界空间。 + + 迭代步长，1点步长相当于unity中的1m + + + + + 获取起点的世界水平面坐标 + + + + + + 获取起点的世界立面坐标 + + + + + + 获取终点的世界水平面坐标 + + + + + + 获取终点的世界立面坐标 + + + + + + 获取起点的世界水平面法线 + (世界空间法线会随着物体世界旋转而旋转) + + + + + + 获取起点的世界立面法线 + (世界空间法线会随着物体世界旋转而旋转) + + + + + + 获取终点的世界水平面法线 + (世界空间法线会随着物体世界旋转而旋转) + + + + + + 获取终点的世界立面法线 + (世界空间法线会随着物体世界旋转而旋转) + + + + + + 获取轨迹长度 + + + + + + 寻找最近的使用线上单位长度驱动的点位 + + + + + + 寻找最近的使用线上单位长度驱动的点位 + + + + + + 寻找最近的使用线上未钳制的单位长度驱动的点位 + + + + + + 寻找最近的使用线上未钳制的单位长度驱动的点位 + + + + + + 获取给定单位长度上的点位 + + + + + + + 获取给定单位长度上的点位 + + + + + + + 获取离给定坐标最近的点 + + + + + + + 获取离给定坐标最近的点 + + + + + + + 线段渲染 + + + + + 检查此渲染组件是否正常 + + + + + 将渲染器切换到世界空间(拖动对象原点将不会改变渲染位置) + + + + + 将渲染器切换到本地空间(拖动对象也会改变渲染位置) + + + + + 设置渲染线段上的一系列点 + + + + + 设置渲染线段上的给定索引的一个点的坐标 + + + + + + + 适用于需要在对象内额外定义操作步骤的成员。 + + + + + 获取操作步骤序列 + + + + + + 用于支持自定义渲染的组件 + + + + + 渲染有效 + + + + + 可序列化的对象后处理 + + + + + 呼叫序列化发生 + + + + + 反序列化前检查标志 + + + 可以继续执行返回真，否则为否 + + + + 呼叫反序列化发生 + + 首先发生的反序列化事件，用于反序列化全局索引，以及一些没有依赖引用关系的参数 + + + + + + 滞后的反序列化发生 + + 比如将引用关系放在滞后反序列化中进行构建，此时全局索引已经构建，所以可以不用考虑目标是否还在序列化等问题。 + + + + + + 空间维度转换，用于2维轨迹中后续对于坐标矢量的描述 + + + + + 强制获取此实现在三维空间中的坐标 + + + + + + 强制获取此实现在地平面中的坐标 + + + + + + 强制获取此实现在纵版空间中的坐标 + + + + + + 强制设置此实现在三维空间中的坐标 + + + + + + 强制设置此实现在地平面中的坐标 + + + + + + 强制设置此实现在纵版空间中的坐标 + + + + + + 获取此轨迹的点位迭代器，无论如何都会返回包含首尾的点坐标。 + + 注意：这是本地空间 + 另外有些时候在计算的最后不满两步长的点可能会被省略。 + + + 迭代步长，1步长接近于unity中的1m + 返回双精浮点的XY值 + + + + 相对原点，如果当前是世界空间，可以使用此项目进行坐标偏移； + 如果当前是本地空间，此项应当为零; + + 注意：此项主要用于设置坐标偏移，是本地空间 + 并且它的坐标可能并不是真的是中心点。 + + + + + + 获取起点法向 + + 注意：这是模拟空间，世界或本地旋转对此无效 + + + + + + + 获取终点法向 + + 注意：这是模拟空间，世界或本地旋转对此无效 + + + + + + + 获取起点坐标 + + 注意：这是模拟空间 + + + + + + + 获取终点坐标 + + 注意：这是模拟空间 + + + + + + + 获取轨迹长度 + + 注意：这是模拟空间，世界或本地缩放对此无效 + + + + + + + 获取给定点在轨迹上的单位长度 + + 注意：这是模拟空间，世界或本地缩放对此无效 + + + 轨迹上的坐标 + 返回的是一个被钳制在0-1之间的值 + + + + 获取给定点在轨迹上未被钳制的单位长度 + + 注意：这是模拟空间，世界或本地缩放对此无效 + + + + + + + + 获取此轨迹上单位长度上的点坐标，注意这不会进行单位长度钳制 + + 注意：这是模拟空间，世界或本地缩放对此无效 + + + 单位长度 + + + + + 获取离给定点最近的点坐标 + + 注意：这是模拟空间，不能与世界空间坐标混用 + + + + + + + + 具有全局唯一标识符的 + + + + + 标识符成员 + + + + + 三维轨迹类接口，实现接口的类可以用于驱动线 + + + + + 二维轨迹类接口，实现接口的类可以用于驱动线 + + + + + 决策者工具，创建一个工具类，来对所有的输入进行决策分离。 + + 说明： + 决策者工具是一种通过输入产生操作的代理工具，所有的操作应该通过决策者工具类代为实现。 + 决策者工具可以在特定的条件下接受来自不同情景的输入（快捷键，或常规操作）， + 切换这个决策者工具即可完成对一系列操作的情景快速切换， + 其中包含一系列操作栈，可以同时操作数个对象。 + + 通常情况下只能有一个决策者工具在线，这将会占用静态名额； + 其他启动的决策者工具会关闭当前激活的决策者。 + 不论工具是否启用，都可以调用updateDMTool()，这会自动路由到所需的工具上。 + + 注意： + 工具内异步更新将按顺序执行，这十分缓慢，很可能会因为无法准时完成任务延迟多帧。 + 异步期间无法访问所有的的运行时参数，需要另外为异步创建所需的备份，注意不要给GC带来过大的压力。 + + + + + + 当对象增加时 + + + + + 当对象减少时 + + + + + 所有决策者工具 + + + + + 所有可用的工具数量 + + + + + 获取给定索引下的工具 + + + + + + + 移除工具 + + + + + 当前激活的决策者工具 + + + + + 当前激活的辅助决策者 + + + + + 决策者更新，这会自动路由到当前激活的决策工具上。 + + + + + 按键状态 + + + + + 第一按键状态 + + + + + 第二按键状态 + + + + + 任何键按下 + + + + + 所有使用的按键，一般来说真的要用的按键并不多，而且并不频繁修改。 + + + + + 按键状态快照 + + 如果直接遍历所有按键，将有2ms的GC，并不高效； + 这也是为什么需要先申请一个按键 + + + + + + 检查一个按键是否已经存在 + + + + + + + 请求一个按键处理，以便后续使用 + + + + + + 驳回一个按键处理 + + + + + + 获取按键状态 + + + + + + + 获取上一按键状态 + + + + + + + 获取按键按下时 + + + + + + + 获取按键释放时 + + + + + + + 获取按键状态不一致时（按下或释放） + + + + + + + 获取任意键状态按下时 + + + + + + 第一按键状态 + + + + + 第二按键状态 + + + + + 任何键按下 + + + + + 鼠标状态快照 + + 如果直接遍历所有按键，将有2ms的GC，并不高效； + 这也是为什么需要先申请一个按键 + + + + + + 获取按键状态 + + + + + + + 获取按键按下时 + + + + + + + 获取按键释放时 + + + + + + + 获取按键状态不一致时（按下或释放） + + + + + + + 获取任意键状态按下时 + + + + + + 按键包 + + 包装一个按键事件 + + + + + + 指代按键 + + + + + 鼠标按键 + + + + + 当前按键是键盘 + + + + + 此按键包监听指定的非鼠标按键 + + + + + + 此按键包监听一个指定的鼠标按键 + + + + + + 初期化参数，只针对部分特殊临时状态 + + + + + 获取包装按键状态，如果定义了多个按键，则所有按键都按下了才有效 + + + + + + 获取包装按键按下，如果定义了多个按键，则任意按键按下了都有效 + + + + + + 获取包装按键释放，如果定义了多个按键，则任意按键释放了都有效 + + + + + + 获取包装按键差异，如果定义了多个按键，则任意按键发生差异都有效 + + + + + + 获取包装按键组合按下，当最后一个按键按下时触发 + + + + + + 获取任意按键按下时 + + + + + + 获取按下翻页的按键状态 + + + + + + 获取释放翻页的按键状态 + + + + + + 隐式获取一个按键包的按键 + + + + + + 工具开始执行 + + + + + 工具结束执行 + + + + + 工具是否有效 + + + + + 是否启用批处理异步前置更新 + + 注意：这会带来更大的开销 + + + + + + 是否启用批处理异步后置更新 + + 注意：这会带来更大的开销 + + + + + + 操作栈插槽链表，每个插槽代表一个成员 + + + + + 操作栈插槽列表，这里不用它作为索引依据的原因是因为这是异步的 + + + + + 工具元素父级 + + + + + 工具元素父级有效 + + + + + 开启序列化时的压缩功能 + + 开启后会大大降低占用空间，但会使输出不再具有可读性，并带来一定的性能问题。 + 默认开启。 + + + + + + 创建一个基本操作工具 + + 每个工具中包含一系列的操作栈列，启用工具将直接执行这些操作。 + 当工具中的操作栈全部结束时，工具将会自动关闭。 + 监听工具的开始与结束委托来快速跟踪工具状态。 + + + + + + 销毁工具 + + + + + 初始化工具父级 + + + + + 工具初始构造时 + + + + + 当决策工具启用时，上一个工具会在此之前调用OnDisableTool并结束 + + + + + 当决策工具停用时 + + + + + 工具更新生命周期 + + 基类必须继承，用以实现栈批处理更新 + + + + + + 工具后置更新生命周期 + + 基类必须继承，用以实现栈批处理更新 + + + + + + 当工具被标记为辅助并开始执行时 + + + + + 当工具结束辅助工具时 + + + + + 工具后台主要更新 + + 不建议在后台执行按键操作等关键操作，而是应该将主要逻辑放在当前激活的工具上。 + + + + + + 工具后台后置更新 + + 不建议在后台执行按键操作等关键操作，而是应该将主要逻辑放在当前激活的工具上。 + + + + + + 工具被激活，逻辑递交前台 + + + + + 工具休眠，逻辑递交后台 + + + + + 当工具中的首个操作栈开始使用时 + + + + + 当工具最后一个操作栈结束使用时 + + 基类必须继承，提供必要的结束回调 + + + + + + 决策工具启动过程 + + 对于过程来说_enableTool是常量，可以检查，不能写入 + + + + + + 决策工具关闭过程 + + 对于过程来说_enableTool是常量，可以检查，不能写入 + + + + + + 序列化与反序列化缓冲区 + + + + + 序列化与反序列化缓冲区 + + 只能在工具序列化处理阶段中调用 + + + + + + 序列化类型映射集合 + + + + + 序列化类型映射集合 + + + + + 工具序列化处理 + + 在序列化方法中可以使用： + SerializeTemp作为序列化的缓冲区； + TypeConsignMap作为目标类标识的映射管理； + + 可以使用 SerializeTemp.Add 来添加新的元素，以将其纳入序列化范围； + 并在所有元素添加结束后调用 SerializeTemp.RefreshSerializedContext() 来刷新缓存。 + 如果不刷新缓存会导致所有序列化的内容清零。 + + + + + + + 工具反序列化处理 + + 在反序列化方法中可以使用： + SerializeTemp作为序列化内容的获取； + TypeConsignMap作为目标类标识的映射获取； + + + + 如果传入的集合无法进行序列化，返回否 + + + + 在序列化中添加类型 + + 请在ToolSerializeDispost方法中基类方法之后调用 + + + + + + + + 获取当前反序列化的类型 + + 请在ToolDiserializDispost方法中基类方法之后调用 + + + + 真则代表当前类型有效 + + + + 创建一个操作插槽 + + + + + + + 添加一个现有的操作插槽 + + + + + + 嵌入插槽 + + + + + + 移除一个操作插槽 + + + + + 用新的插槽替换当前插槽 + + + + + + + 查找一个对象在哪个节点中 + + + + + + 清除所有成员 + + + + + 即刻创建一个用于建造的对象 + + 创建成员的连带功能： + * 创建时加入建造队列。 + * 名称是自动按照当前的时间序列给定，全局唯一。 + + + + + + + 创建一个可放置的元素 + + 建造目标的类型 + 目标名称 + + + + + 重做撤回操作的基类 + + + + + 后端控制台工具，直接接收输入按键并构建为字符串 + + + + + 输入更新时 + + + + + 输入文本缓冲区 + + + + + 获取文本 + + + + + 更新按键输入 + + + + + 清除缓冲区 + + + + + 轨迹跟踪工具 + + 轨迹跟踪可以计算出一个受路径影响的光标，用于路径上吸附。 + + 注意：这是一个后台工具，不需要置于前台 + + + + + + 设定追踪器检查范围 + + + + + 跟踪目标坐标（这默认是小型占位模式） + + + + + 跟踪目标（这默认是小型占位模式） + + + + + 目标索引 + + + + + 所有期望获取的通讯目标 + + + + + 世界光标位置 + + + + + 持续获取追踪目标的结构 + + + + + 类型 + + + + + 有效的距离 + + + + + 最近的距离 + + + + + 最近的位置 + + + + + 最近的物体 + + + + + 创建追踪目标权重对 + + + + + 开始计算 + + + + + 结束计算 + + + + + 直接计算过程 + + + + + 根据当前的模式类型计算过程 + + + + + + 清空 + + + + + 获取光标在当前网格中的最近的邻居。 + + 结果会放在类字段: + 吸附坐标：_trackingCurrentPosition + 吸附对象: _trackingCurrentTarget + + + + + + 获取追踪计算器 + + + + + + 创建一个新的追踪计算器 + + 返回一个追踪计算器，这会和其他计算器同时计算，但返回关注点不同的结果 + 注意：这会带来额外的性能开销。 + + + + + + 移除一个追踪计算器 + + 注意，请注意保留至少一个计算器在工具内，全部删除可能导致获取默认值时抛出异常 + + + + + + + + 摄像机视图下输入辅助，用来提供用户在 + + + + + 摄像机换源委托 + + 新的摄像机 + + + + 当主要的摄像机发生变更时 + + + + + 鼠标输入更新委托 + + 鼠标落点有效 + 鼠标在世界中的落点 + + + + 鼠标输入更新 + + + + + 此控制器输入是否启用 + + + + + 此控制器摄像机换源检查是否有效，如果游戏中需要切换摄像机，那么应该开启检查。 + + + + + 获取当前第一个被标记为有效的摄像机。 + (注意：这是惰性属性，获取的是一个本地变量) + + + + + 光标在世界中命中的坐标 + + + + + 光标在世界中的网格吸附坐标 + + + + + 光标在屏幕上的坐标 + + + + + 命中点有效 + + + + + 鼠标光标在世界中的碰撞检测层 + + + + + 鼠标光标在世界中的最大碰撞距离 + + + + + 鼠标光标在世界中吸附的尺寸 + + + + + 调试移动目标 + + + + + 控制是否在世界中绘制光标射线 + + + + + 控制是否在世界中绘制光标附近的网格 + + + + + 更新主要摄像机，随后可以使用_mainCamera获取引用。 + + + + + 获取鼠标在世界空间中的点 + + + + + + + + + 将给定的点吸附到绝对网格 + + 点坐标 + 网格 + + + + + 替换碰撞结果中的坐标 + + + + + + + + 获取一个矢量吸附在此处定义的网格上的值。 + + + + + + 伪造一个射线检测结果 + + 如果不想要进行射线检测，那么在此处提供必要的属性即可创建一个满足要求的射线检测结果。 + (注意：潜在的较大开销方法) + + + 命中位置 + 命中对象 + 返回命中结果 + 命中位置的法向 + 当目标的碰撞检测层不一致时将返回否 + + + + 建造放置元素的管理器，用于控制元素的渲染生命周期 + + 默认开启了输入控制，可以通过EnableInputHelper字段来设定是否启用。 + + 在没有任何工具启动的情况下，管理器可以接收按键输入，直到被工具输入抢占。 + 不过这里并没有抢占逻辑，所以请根据工具激活的逻辑适时关闭按键处理 + + 使用前须知： + 代理生命周期元素需要通过AddEmbedded加入；同时默认关闭主要的更新过程，需要设置EnableUpdate为true; + + + + + + 允许可放置对象的前置更新 + + + + + 允许可放置对象的主要更新 + + + + + 允许可放置对象的后置更新 + + + + + 线材质 + + + + + 点材质 + + + + + 网格原点 + + + + + 晶格尺寸 + + + + + 网格总尺寸 + + + + + 网格最大邻居数量 + + + + + 全体可放置元素的邻居 + + + + + 可放置物对象的批处理列表 + + + + + 全体结构链表 + + + + + 所有结构链表 + + + + + 输入管理器 + + + + + 此管理器的输入代理控制是否有效 + + + + + 线路追踪工具 + + + + + 将一个成员添加到此处的代理生命周期中 + + + + + + + 将一个成员从此处的代理生命周期中移除 + + + + + + + 初始化邻居网格 + + + + + 添加巨大邻居对象 (一个横跨多个网格点的对象称为巨大对象，需要里面包含一个线计算器) + + + + 由外部决定如何变换坐标空间（目标，建议步长）返回点位迭代器 + + + + + + 移除巨大邻居对象 + + + + 由外部决定如何变换坐标空间（目标，建议步长）返回点位迭代器 + + + + 清空此集线器上的所有的索引 + + + + + + + 添加一个相邻元素，用于后续通过坐标进行查找 + + + + + + 移除一个网格元素 + + + + + + 移除一个网格元素 + + + + + + 代理请求一个按键 + + + + + + 代理拒接一个按键 + + + + + + 添加可管理对象到此管理器中 + + 加入的成员可以享受序列化与反序列化服务，以及后续的一系列管理方法 + + + + + + + + 将一个可管理对象从此管理器中移除 + + 移除的成员将无法继续享受序列化服务 + + + + + + + 贝塞尔曲线轨迹计算器 + + + + + 项数 + + + + + 弧形轨迹计算器 + + + + + 长度溢出此范围时，返回为否表示不允许继续绘制 + + + + + 最大弧长计算积分间隔 + + + + + x坐标 + + + + + y坐标 + + + + + x半径 + + + + + y半径 + + + + + 圆弧起点或反转时的终点 + + + + + 圆弧终点或反转时的起点 + + + + + 是否顺向，表示从a到b的轨迹为顺时针，否则为逆时针 + + + + + 制作切向正圆弧 + + 相对坐标 + 切线空间 + 相对坐标 + 交换绘制方向，用于半圆弧与全圆弧切换 + 如果条件不满足则返回否 + + + + 制作切向正圆弧 + + 相对坐标 + 相对坐标 + + 交换绘制方向，用于半圆弧与全圆弧切换 + 如果条件不满足则返回否 + + + + 制作角度约束圆弧（圆弧会自行计算得到一个新的顶点） + + 局部空间 + 切线空间 + 局部空间 + + 交换绘制方向，用于半圆弧与全圆弧切换 + + + + + 制作两法线完全约束圆弧(圆弧参考两个法向的方向进行绘制) + + 局部空间 + 切线空间 + 局部空间 + + 交换绘制方向，用于半圆弧与全圆弧切换 + + + + + 逼近椭圆弧弧长，这是有一定误差的计算方法，具体取决于积分间隔 + + + + + + 积分间隔数 + + + + + 获取正圆弧长 + + 半径 + 起始弧长 + 结束弧长 + 顺向控制 + + + + + 获取弧长 + + 如果当前是非正圆弧，需要设定积分逼近细节，建议保持默认 + + + + + 获取给定弧度上的切线斜率与截距 + + 测量弧度 + 斜率 + 截距 + + + + 获取给定弧度上的坐标 + + 单位是弧度 + 向量的起点与法向 + + + + 获取给定弧度上的切线向量 + + 单位是弧度 + 向量的起点与法向 + + + + 获取给定弧度下的坐标 + + + + + + + 通过二分法确定一个点在圆弧的位置 + + + + + + + 通过投影计算一个点在圆弧上的弧度 + + + + + + + + 通过投影计算一个点在圆弧上的位置（最近的位置） + + + + + + + + 圆弧方向是否顺向，通常在绘制上有顺序之分，顺向表示当前圆弧从点A到点B的顺序是顺时针的 + + 注意：这并不意味着点A和点B的顺序是沿当前表示的顺时针的方向排列的， + + + + + + 把这个圆弧当作正圆弧来获取半径 + + + + + 获取这段圆弧上两个端点形成的角度 + + + + + 获取这段圆弧上两个端点形成的角度 + + + + + 获取正圆圆弧弦长 + + + + + 获取正圆弦高（圆上任意两点间中点垂直到圆弧的距离） + + + + + 弓形高（圆弧的两点间中点到圆心的距离） + + + + + 获取椭圆弧弦长 + + + + + 获取椭圆弧弦高 + + + + + 获取椭圆弧弓形的高 + + + + + 直线轨迹计算器 + + + + + 创建直线 + + + + + + + 创建直线 + + + + + + + + 获取给定坐标点处相当于当前线的单位长度 + + + + + + + 获取给定点坐标处相当于当前线的未钳制单位长度 + + + + + + + 基础轨迹类 + + + + + 弧度转角度 + + + + + 角度转弧度 + + + + + 最大可接受的误差 + + + + + 正循环，三角取整 + + + + + + + + 二维叉乘 + + + + + + + + 极坐标空间转单位空间(指的是将(-π, π)范围的取值转为(0, 1)) + + 极坐标空间 + 此操作不会破坏空间连续性 + + + + 单位空间转极坐标空间(指的是将(0, 1)范围的取值转为(-π, π)) + + 单位极坐标空间 + + + + + 从两线获取相交点(矩阵思想) + + + + + + 获取两线是否相交(矢量变换思想) + + 线1起点 + 线1终点 + 线2起点 + 线2终点 + 输出交点 + + + + + 占用区域，描述一个物体的占用范围，并根据规则遍历这个范围。 + + + + + 关注的占位符类型 + + + + + 小型占位符元素，只占用单个检索网格数据结构 + (占用原点) + + + + + 大型占位符元素，占用一块矩形的地块 + (占用矩形范围) + + + + + 路径占位符元素，使用其中的轨迹占用检索数据结构 + (占用轨迹) + + + + + 异型占位符元素，是其他没有约定的形状。 + (使用其他特殊形状) + + + + + 退出状态，等待所有项目异步执行完毕后退出操作栈 + + + + + 稳定状态 + + + + + 在放置对象时进行按键等待，左键下一步，右键上一步 + + 这是一个模拟双稳态的行为节点， + 通过初始化其中上一步和下一步将要执行的节点目标 + + + + + + 获取退出的方法 + + + + + + 下面捕获的值是有效的 + + + + + 鼠标在场景中的坐标值是有效的 + + + + + 在用户输入下一步时，鼠标在世界的坐标 + + + + + 在用户输入下一步时，鼠标在屏幕上的坐标 + + + + + 下面捕获的值是有效的 + + + + + 鼠标在场景中的坐标值是有效的 + + + + + 在用户输入下一步时，鼠标在世界的坐标 + + + + + 在用户输入下一步时，鼠标在屏幕上的坐标 + + + + + 初始化等待用户输入行为节点的双稳态目标 + + 下一步节点目标 + 上一步节点目标 + + + + 将鼠标的坐标捕获到本地 + + + + + 取消按键检查 + + + + + + 按下继续的按钮 + + + + + + 跳转到上一步 + + + + + 跳转到下一步 + + + + + 操作栈插槽，对应一个需要被工具控制的对象，以及控制它的一系列事件，属性。 + + 操作栈是一个操作行为树，其中遍布插槽，插槽中包含具体行为，并定义了状态转换的过程。 + 操作栈（行为树） -> 操作插槽 -> 行为 -> 状态切换 + + 你可以通过在工具类上调用GenerateOperateSlot来创建一个指定类的插槽， + 切换状态时可以直接new一个新的派生自OperateSlot的类，通过ReplaceThis来切换状态，而不会改变其中的目标成员。 + + + + + + 默认的空操作结构 + + + + + 当前所处的工具类，应当保持引用，当抛弃引用时，说明此插槽已被废弃。 + + + + + 按栈结构顺序的下一个操作栈插槽 + + + + + 按栈结构顺序的上一个操作栈插槽 + + + + + 当前栈表运行到此的路径结构，只有当执行了替换时才会发放值 + + + + + 按时间顺序在此之前的一个栈节点 + + + + + 当前栈节点是否存在时间上的上一个节点 + + + + + 操作目标对象 + + + + + 用新的插槽替换此处的成员，表示此成员切换了状态 + + + + + + 移除自己 + + + + + 更新 + + 在这里进行主要的逻辑切换，使用ReplaceThis(newSlot)来切换流程； + 注意不要进行复杂的操作，减少日志打印的调用。 + + + + + + 开始时 + + + + + 结束时 + + + + + 异步更新前同步更新 + + + + + 异步更新 + + + + + 异步更新后同步更新 + + + + + 全局唯一标识符 + + 可以用于数组标识，其中的id在运行期间不会改变。 + 如果要移除对象，记得先使用Invalidation无效化索引。 + + + + + + 全局唯一计数器，计数器只包含有效的成员数量，不包括虽然存在，但已被回收的成员 + + + + + 回收id，虽然存在，但是不算在全局的id计数中 + + + + + 已经存在的ID + + + + + 检查一个id是否已经存在，时间复杂度接近O(1) + + + + + + + 尝试获取给定的id的引用 + + + + + + + + 标识符ID + + + + + 标识符有效 + + + + + 映射对象 + + + + + 标识符状态 + + + + + 被标记的伪装，或从反序列化得来，这是默认值 + + + + + 正常的标识符状态 + + + + + 标识符正常状态 + + + + + 映射关系正常 + + + + + 创建全局唯一标识符 + + + + + 直接创建一个标识符 + + + + + + + 无效化索引，表示此标识符不再使用，等待回收 + + + + + id是有效的(索引正常，且映射正常) + + + + + + 与ToString对应，可以将一个包含基本标识符的目标转为标识符 + + + + + + + + 隐式获取标识符索引 + + + + + + 群组链接 + + + 线性链接 + + + + + 链接成员链表 + + + + + 连接成员迭代器 + + + + + 组链接映射器 + + + + + 目标 + + + + + 类型 + + + + + 构建一个组链接映射器 + + + + + + + 线性链接 + + + + + 链接成员 + + + + + 将一个成员直接替换到目标上 + + + + + + + 链路扩展 + + + + + 从别人的结构中找到自己 + + 目标 + 自己 + 别人眼中的自己 + + + + 在给定的节点上遍历首个节点，直到结束。 + + 注意：遍历是有限的，你不能无限遍历一个循环链路， + 线路的遍历应该抽象给行为树，由行为树节点在有限的空间中进行遍历。 + + + + 遍历的第一个节点是传入的节点 + + + + 在给定的节点上遍历链路，这是一种辅助遍历的方法 + + 遍历的行为需要在循环体内定义，需要对每次循环提供的回调器设定下一步的目标。 + 如果没有设定目标，或目标未变更，那么再次遍历时，循环将自动退出。 + + 注意：遍历是有限的，你不能无限遍历一个循环链路， + 线路的遍历应该抽象给行为树，由行为树节点在有限的空间中进行遍历。 + + + 起点方向 + + 提供一个遍历描述回调，这在阶段中唯一，首个遍历对象是传入节点本身 + + + + 链路遍历描述回调器 + + + + + 当前目标 + + + + + 定义方向 + + + + + 执行检查 + + + + + 设置下一步的目标 + + + + + + 获取当前目标 + + + + + + 设定下一步的运行方向 + + + + + + 获取下一步的运行方向 + + + + + + 设定当前节点阻塞，下一步可以尝试遍历兄弟节点 + + + + + 获取当前遍历节点的历史 + + + + + + 获取历史节点计数 + + + + + + 链路链接类型 + + 可以与 LinkedPortType 直接相转换 + + + + + + 输入 + + + + + 输出 + + + + + 链路的端口类型 + + 可以与 LinkType 直接相转换 + + + + + + 输出端口 + + + + + 输入端口 + + + + + 翻转连接状态 + + + + + + + 翻转接口状态 + + + + + + + 转换连接状态为接口状态 + + + + + + + 转换接口状态为连接状态 + + + + + + + 绘制路径点集 + + 路径点集是一个世界中用于参考的点的集合。 + + + + + + 此路不通 + + + + + 需要大于1段线才可以拟合的路径 + + + + + 路径点迭代器 + + + + + 运行工况枚举 + + + + + 开始时 + + + + + 正在运行 + + + + + 状态呈递 + + + + + 结束 + + + + + 错误 + + + + + 委托代理事件枚举执行器 + + 给定执行流程，在随后的stepRun中被按阶段执行。 + 可以调用end方法在运行过程中结束事件。 + + + + + + 标记为快速执行，在执行完first后立刻执行run + + + + + 创建一个委托代理，并指定运行时的各项状态 + + 如果没有需要执行或传递的成员，可以返回null + 返回一个枚举器，而不是直接定义成枚举器 + 如果没有需要执行或传递的成员，可以返回null + 快速运行，可能会破坏原有的执行顺序 + + + + 单步执行 + + + 如果执行完毕，返回为否 + + + + 结束执行，需要等到下次执行时才结束 + + + + + 立刻结束执行 + + + + + 操作栈回调 + + + + + 单步设置 + + + + + 单步设置 + + + + + 操作序列器 + + 步骤序列器中包含多个委托构成的步骤，每个步骤都将循环执行， + 通过序列器中预设的方法来控制流程方向。 + + + + + + 操作步骤序列 + + + + + 当前操作序列正在运行 + + + + + 运行 + + + + + 当前活动的操作步骤 + + + + + 单步运行，如果要开始运行，需要先调用StartRun + + 如果运行结束或运行无效，返回否 + + + + 开始运行，接下来允许通过StepRun运行 + + + + + 中止运行，这不会立刻停止运行，而是需要等下下一次单步运行时退出 + + + + + 立刻停止运行，并释放操作栈 + + + + + 添加一个步骤 + + + + + + 清空步骤 + + + + + 当前项目的代理序列化器 + + + + + 变换组件序列化结构 + + + + + 顺序反序列化变换组件 + + + + + + + + 序列化索引结构 + + + + + 创建一个序列化结构 + + + + + + 校验索引 + + 如果当前的情况需要进一步处理，则返回真（比如没目标，不与其他id冲突时） + + + + + 顺序反序列化索引 + + + + + + + + 序列化线性链接 + + + + + 创建一个序列化结构 + + + + + + 顺序反序列化线性链接结构 + + + + + + + + 序列化组链接 + + + + + 创建一个序列化结构 + + + + + + 顺序反序列化组链接 + + + + + + + + 序列化直线轨迹 + + + + + 创建一个序列化结构 + + + + + + 顺序反序列化直线轨迹 + + + + + + + + 序列化圆弧轨迹 + + + + + 创建一个序列化结构 + + + + + + 顺序反序列化圆弧轨迹 + + + + + + + diff --git a/Runtime/EditorTool/ShowMyNameInScene.cs b/Runtime/EditorTool/ShowMyNameInScene.cs new file mode 100644 index 0000000..8b2d2b6 --- /dev/null +++ b/Runtime/EditorTool/ShowMyNameInScene.cs @@ -0,0 +1,132 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.Text; +using UnityEngine; +using UnityEngine.Serialization; +using XericLibrary.Runtime.CustomEditor; +using XericLibrary.Runtime.MacroLibrary; +using XericLibrary.Runtime.Type; + +#if UNITY_EDITOR +using UnityEditor; +#endif + +public class ShowMyNameInScene : MonoBehaviour +{ + [Rename("")] public bool Enable = false; + [Rename("ѡʱʾ")] public bool OnlyShowOnSelect = false; + [Rename("Ŀ")] public bool ShowAllChindName = true; + [Rename("ʾ")] public bool ShowGameObjectName = false; + [Rename("ʾģ")] public bool ShowMeshFilter_MeshName = false; + + public bool RandomEachObjectColor = false; + public Color TextColor = Color.white; + public RectOffset TextBorder = new RectOffset(0,0,0,0); + public RectOffset TextMargin = new RectOffset(0,0,0,0); + public RectOffset TextPadding = new RectOffset(0,0,0,0); + public RectOffset TextOverflow = new RectOffset(0,0,0,0); + public Font font; + public int fontSize = 0; + public FontStyle fontStyle = FontStyle.Normal; + public TextClipping TextClipping = TextClipping.Overflow; + public ImagePosition ImagePosition = ImagePosition.ImageLeft; + public Vector2 ContentOffset = Vector2.zero; + public Vector2 FixedSize = Vector2.zero; + public Bool2 Stretch = new Bool2(); + + private GUIStyle TextStyle; + private StringBuilder _sb = new StringBuilder(); + +#if UNITY_EDITOR + private void OnDrawGizmos() + { + if (!Enable) + return; + if (OnlyShowOnSelect && !ReferenceEquals(Selection.activeGameObject, this)) + return; + + TextStyle = new GUIStyle() + { + normal = new GUIStyleState() + { + textColor = TextColor, + // background = + }, + border = TextBorder, + margin = TextMargin, + padding = TextPadding, + overflow = TextOverflow, + font = font, + fontSize = fontSize, + fontStyle = fontStyle, + richText = true, + clipping = TextClipping, + imagePosition = ImagePosition, + contentOffset = ContentOffset, + fixedHeight = FixedSize.y, + fixedWidth = FixedSize.x, + stretchHeight = Stretch.y, + stretchWidth = Stretch.x, + }; + + if (ShowAllChindName) + { + foreach (var item in transform.GetChildren()) + { + if (!item.gameObject.activeInHierarchy) + continue; + SwitchFilter(item); + } + } + else + { + DrawGameObjectNameInScene(transform, transform.name); + } + } + + private void SwitchFilter(Transform target) + { + if (_sb == null) + _sb = new StringBuilder(); + _sb.Clear(); + + if (RandomEachObjectColor) + TextStyle.normal.textColor = MacroColor.RandomHueColor(target.gameObject.GetInstanceID()); + + var position = target.position; + var mf = target.GetComponent(); + if (mf != null) + { + var mesh = mf.mesh; + if (mesh != null) + position += target.rotation * mesh.bounds.center; + } + + if (ShowGameObjectName) + _sb.AppendLine($"Name: {target.name}"); + + if (ShowMeshFilter_MeshName) + _sb.AppendLine($"Mesh: {GetComponentName(target, a => a.mesh?.name ?? "unknown")}"); + + DrawNameInScene(position, _sb.ToString()); + } + + private void DrawGameObjectNameInScene(Transform obj, string name) + { + Handles.Label(obj.position, name,TextStyle); + } + + private void DrawNameInScene(Vector3 position, string name) + { + Handles.Label(position, name, TextStyle); + } + + private string GetComponentName(Transform target, Func getName) + where T : Component + { + return getName(target.GetComponent()); + } + +#endif +} \ No newline at end of file diff --git a/Runtime/Helper/XericHelper.cs b/Runtime/Helper/XericHelper.cs new file mode 100644 index 0000000..a73ce63 --- /dev/null +++ b/Runtime/Helper/XericHelper.cs @@ -0,0 +1,31 @@ +using System.Collections; +using System.Collections.Generic; +using UnityEngine; + +namespace Deconstruction.Runtime +{ + /// + /// Xeric ʱ + /// + public static class XericHelper + { + #region + + /// + /// 뿪Ϸģʽ(ڱ༭ģʽʱ˳) + /// + public static void ExitGameMode() + { +#if UNITY_EDITOR + if (Application.isPlaying) + { + UnityEditor.EditorApplication.ExitPlaymode(); + } +#else + Application.Quit(); +#endif + } + + #endregion + } +} diff --git a/Runtime/HorizonLineOrbit/.idea/.idea.HorizonLineOrbit.dir/.idea/encodings.xml b/Runtime/HorizonLineOrbit/.idea/.idea.HorizonLineOrbit.dir/.idea/encodings.xml new file mode 100644 index 0000000..df87cf9 --- /dev/null +++ b/Runtime/HorizonLineOrbit/.idea/.idea.HorizonLineOrbit.dir/.idea/encodings.xml @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/Runtime/HorizonLineOrbit/.idea/.idea.HorizonLineOrbit.dir/.idea/indexLayout.xml b/Runtime/HorizonLineOrbit/.idea/.idea.HorizonLineOrbit.dir/.idea/indexLayout.xml new file mode 100644 index 0000000..7b08163 --- /dev/null +++ b/Runtime/HorizonLineOrbit/.idea/.idea.HorizonLineOrbit.dir/.idea/indexLayout.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/Runtime/HorizonLineOrbit/.idea/.idea.HorizonLineOrbit.dir/.idea/projectSettingsUpdater.xml b/Runtime/HorizonLineOrbit/.idea/.idea.HorizonLineOrbit.dir/.idea/projectSettingsUpdater.xml new file mode 100644 index 0000000..4bb9f4d --- /dev/null +++ b/Runtime/HorizonLineOrbit/.idea/.idea.HorizonLineOrbit.dir/.idea/projectSettingsUpdater.xml @@ -0,0 +1,6 @@ + + + + + \ No newline at end of file diff --git a/Runtime/HorizonLineOrbit/.idea/.idea.HorizonLineOrbit.dir/.idea/vcs.xml b/Runtime/HorizonLineOrbit/.idea/.idea.HorizonLineOrbit.dir/.idea/vcs.xml new file mode 100644 index 0000000..b2bdec2 --- /dev/null +++ b/Runtime/HorizonLineOrbit/.idea/.idea.HorizonLineOrbit.dir/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/Runtime/HorizonLineOrbit/.idea/.idea.HorizonLineOrbit.dir/.idea/workspace.xml b/Runtime/HorizonLineOrbit/.idea/.idea.HorizonLineOrbit.dir/.idea/workspace.xml new file mode 100644 index 0000000..fe192f3 --- /dev/null +++ b/Runtime/HorizonLineOrbit/.idea/.idea.HorizonLineOrbit.dir/.idea/workspace.xml @@ -0,0 +1,60 @@ + + + + + + + + + + + { + "associatedIndex": 7 +} + + + + + + + + + 1740962660807 + + + + + + + + \ No newline at end of file diff --git a/Runtime/HorizonLineOrbit/DrawTerminalLine2T3_OpSlot.cs b/Runtime/HorizonLineOrbit/DrawTerminalLine2T3_OpSlot.cs new file mode 100644 index 0000000..13731fc --- /dev/null +++ b/Runtime/HorizonLineOrbit/DrawTerminalLine2T3_OpSlot.cs @@ -0,0 +1,365 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.Linq; +using Deconstruction.Element; +using Deconstruction.Interface; +using Deconstruction.Manager; +using Deconstruction.Tool; +using Deconstruction.Trajectory; +using Deconstruction.Type.DMToolSlot; +using Deconstruction.Type.Linkable; +using UnityEngine; +using XericLibrary.Runtime.MacroLibrary; + +namespace SesothoLine +{ + using LineSegment2 = Deconstruction.Element.PromptLine2.LineSegment2; + + /// + /// ƹ켣ߵIJ + /// + /// WaitForUserInput_OpSlot˴ʱTerminalLine2T3·Ļƣ + /// ͬʱ·TerminalPoint· + /// + /// ֳ֧·ƣյ + /// ֧β + /// + /// + public class DrawTerminalLine2T3_OpSlot : WaitForUserInput_OpSlot + { + #region ֶ + + /// + /// һ + /// + private Vector3 _lastPointPosition; + + /// + /// һĶ켣 + /// + private Vector3 _lastPointNormal; + + /// + /// һ + /// + private Vector3 _helperPosition = Vector3.zero; + + /// + /// һķ + /// + private Vector3 _helperNormal = Vector3.zero; + + /// + /// Ĺ켣 + /// + private TerminalLine2T3 _line; + + /// + /// + /// + private TerminalPoint _startPoint; + + /// + /// ĵ㣬Ҳյ + /// + private TerminalPoint _endPoint; + + /// + /// ڳҵĵ + /// + private TerminalPoint _otherPoint; + + /// + /// һյ + /// + private bool _isStartPointSubstitute = false; + + /// + /// ʱյɵ + /// + private bool _isFreeEndPoint; + + // public SesothoArrangementWiresTool myWiresTool; + // myWiresTool = targetTool as SesothoArrangementWiresTool; + + #endregion + + #region ÷װ + + /// + /// ԼĹ + /// + private SesothoArrangementWiresTool selfWiresTool => SesothoPeManager.WiresTool; + + #endregion + + #region + + protected override void OnStart() + { + base.OnStart(); + + // ִ˴Ƿȷ + if (!HasLastNode) + { + Debug.LogError( + $"ƽڵΪ˳󣬱WaitForUserInput_OpSlotеִ˴"); + RemoveThis(); + return; + } + + if (Last is not WaitForUserInput_OpSlot) + { + Debug.LogError( + $"ƽڵΪ˳Ӧ WaitForUserInput_OpSlot -> {nameof(DrawTerminalLine2T3_OpSlot)}{Last.GetType().Name}"); + RemoveThis(); + return; + } + + // Ⱦ + InitPrecondition(); + } + + protected override void OnEnd() + { + base.OnEnd(); + } + + protected override void Update() + { + // ֹĬϲ + // base.Update(); + + // ߵĻƼ㣬ռӵ + DrawingProcess(); + // ϺִȾпܻ + // ڴ֮ǰĽ׶ѾԴ˽й˴ûйϵҪطճĻҪע⡣ + _line.UpdateRender(); + + // һ + if (IsReleaseContinueKey()) + { + _helperNormal = _line.TrajectoryCalculator.GetEndPointNormal.UpwardPlaneToVector3(); + + // + if (_isStartPointSubstitute) + { + // ڿʼʱѾת + // var dtlt_Slot = Last as DrawTerminalLine2T3_OpSlot; + _line.LinkedDataAddPolarity(_startPoint, LinkType.Import); + } + else + { + _line.LinkedDataAddPolarity(_startPoint, LinkType.Import); + selfWiresTool.PersistentElement(_startPoint); + selfWiresTool.AddPeToNeighborGrid(_startPoint); + } + + // յ + if (_otherPoint is null) // || _endPoint.gameObject.activeSelf + { + _line.LinkedDataAddPolarity(_endPoint, LinkType.Export); + selfWiresTool.PersistentElement(_endPoint); + selfWiresTool.AddPeToNeighborGrid(_endPoint); + } + // Ŀ + else + { + selfWiresTool.DeleteElement(_endPoint); + _line.LinkedDataAddPolarity(_otherPoint, LinkType.Export); + } + + // + _line.ReapplyOrigin(); + selfWiresTool.PersistentElement(_line); + selfWiresTool.AddBulkPeToNeighborGrid(_line); + + // һ + ReplaceThis(new DrawTerminalLine2T3_OpSlot()); + } + // ȡ + else if (IsReleaseCanelKey()) + { + RemoveThis(); + EndPrecondition(); + } + // todo: صһ + /* + * ջĽṹʹòĸ¿Է, + * dzصĹ̿е㸴ӣ + * ҪΪڼ䳷غͳ泷ء + */ + } + + protected override void AsyncBeforeUpdate() + { + base.AsyncBeforeUpdate(); + } + + protected override void AsyncUpdate() + { + base.AsyncUpdate(); + } + + protected override void AsyncAfterUpdate() + { + base.AsyncAfterUpdate(); + } + + #endregion + + #region + + /// + /// Ⱦ + /// + private void InitPrecondition() + { + switch (Last) + { + // ʹǰߵԪ + case DrawTerminalLine2T3_OpSlot dtlt_Slot: + _isStartPointSubstitute = true; + _startPoint = dtlt_Slot._endPoint; + _lastPointPosition = dtlt_Slot._helperPosition; + _lastPointNormal = dtlt_Slot._helperNormal; + break; + // ½ӿռм̳ + case WaitForUserInput_OpSlot wfui_Slot: + if (SesothoArrangementWiresTool.GetNearestObjectAsPoint(out var terminalPoint)) + { + _isStartPointSubstitute = true; + _startPoint = terminalPoint; + _lastPointPosition = terminalPoint.GetPosition3(); + if (SesothoArrangementWiresTool.GetNearestObjectAsLine(terminalPoint, out var terminalLine, + out var normal)) + _lastPointNormal = normal; + else + { + Debug.LogError("󣺵ǰƵ·׼Ŀ겢һ·ʹ˳"); + RemoveThis(); + } + } + else + { + _isStartPointSubstitute = false; + selfWiresTool.GetElement(out _startPoint); + _lastPointPosition = SesothoArrangementWiresTool.OpKey_IgnoreNeighborAdsorption.Getkey() ? + wfui_Slot.MouseHelperPosition : + CameraMouseInputHelper.Inst.GetGridAdsorb(wfui_Slot.MouseHelperPosition); + _lastPointNormal = default; + } + + break; + default: + break; + } + + selfWiresTool.GetElement(out _line); + selfWiresTool.GetElement(out _endPoint); + } + + /// + /// + /// + private void EndPrecondition() + { + selfWiresTool.DeleteElement(_line); + // ܰѱ˵Ķ + if (!_isStartPointSubstitute) + selfWiresTool.DeleteElement(_startPoint); + selfWiresTool.DeleteElement(_endPoint); + } + + + /// + /// ·ƹ + /// + private void DrawingProcess() + { + // ȡǰ + _helperPosition = PlaceElementManager.Inst.InputHelper.CurrentGridPosition; + + _startPoint.transform.position = _lastPointPosition; + + _isFreeEndPoint = true; + // 壬ðһ + if (SesothoPeManager.NearestObject is not null && + SesothoArrangementWiresTool.GetNearestObjectAsPoint(out _otherPoint) && + !SesothoArrangementWiresTool.OpKey_IgnoreNeighborAdsorption.Getkey()) + { + _isFreeEndPoint = false; + if (_endPoint.gameObject.activeSelf) + _endPoint.gameObject.SetActive(false); + + _helperPosition = SesothoPeManager.NearestPoint; + _endPoint.transform.position = SesothoPeManager.NearestPoint; + if (SesothoArrangementWiresTool.GetNearestObjectAsLine(_otherPoint, out var terminalLine, + out var normal)) + _helperNormal = normal; + } + // + // else if (NearestLineTangentObject != null) + // { + // NearestLineTangentPoint + // } + + // ɵ + if (_isFreeEndPoint) + { + if (!_endPoint.gameObject.activeSelf) + _endPoint.gameObject.SetActive(true); + _otherPoint = null; + _helperNormal = default; + _endPoint.transform.position = _helperPosition; + } + + _line.SetLineSegment( + _lastPointPosition, _helperPosition, + _lastPointNormal, _helperNormal + ); + + // ǰߵ߼ԲôȡĽǶ + // if (_line.NowCalculator is RoundTrajectory2 arc) + // { + // Debug.Log($"Ƕ{arc.Angle} {arc.AngleExact}"); + // } + + var forceStr = SesothoArrangementWiresTool.OpKey_ForceStr.Getkey(); + if (forceStr) + _line.DrawStraightLine(); + else + { + var force90Arc = SesothoArrangementWiresTool.OpKey_90Arc.Getkey(); + var force180Arc = SesothoArrangementWiresTool.OpKey_180Arc.Getkey(); + var forceRevCisoid = SesothoArrangementWiresTool.OpKey_RevCisoid.Getkey(); + + + var angle = -1; + if (force90Arc || force180Arc) + { + angle = 0; + if (force90Arc) + angle += 90; + if (force180Arc) + angle += 180; + } + + _line.AutomaticDrawCircularLine(angle, forceRevCisoid); + } + } + + /// + /// ȡµ + /// + /// + private bool GetCurrentObject() + { + // SesothoPeManager. + return false; + } + + #endregion + } +} \ No newline at end of file diff --git a/Runtime/HorizonLineOrbit/ILinkconfident.cs b/Runtime/HorizonLineOrbit/ILinkconfident.cs new file mode 100644 index 0000000..967e037 --- /dev/null +++ b/Runtime/HorizonLineOrbit/ILinkconfident.cs @@ -0,0 +1,24 @@ +using System.Collections; +using System.Collections.Generic; +using UnityEngine; + +namespace SesothoLine +{ + /// + /// ӵĶ󣬱ʾ˳ԱڰһĽڵ㣬 + /// + public interface ILinkconfident + { + /// + /// ȡӵ + /// + /// + /// + public bool GetLinkedNode(out LinkedListNode node); + /// + /// ӵ + /// + /// + public void SetLinkedNode(LinkedListNode node); + } +} diff --git a/Runtime/HorizonLineOrbit/ILinkconfidentPe.cs b/Runtime/HorizonLineOrbit/ILinkconfidentPe.cs new file mode 100644 index 0000000..37989dd --- /dev/null +++ b/Runtime/HorizonLineOrbit/ILinkconfidentPe.cs @@ -0,0 +1,13 @@ +using System.Collections; +using System.Collections.Generic; +using Deconstruction.Element; +using UnityEngine; + +namespace SesothoLine +{ + /// + /// ӵĶ󣬱ʾ˳ԱڰһĽڵ㣬 + /// + public interface ILinkconfidentPe : ILinkconfident + { } +} diff --git a/Runtime/HorizonLineOrbit/SesothoArrangementWiresTool.cs b/Runtime/HorizonLineOrbit/SesothoArrangementWiresTool.cs new file mode 100644 index 0000000..9032b58 --- /dev/null +++ b/Runtime/HorizonLineOrbit/SesothoArrangementWiresTool.cs @@ -0,0 +1,558 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.Linq; +using System.Runtime.CompilerServices; +using Deconstruction.Element; +using Deconstruction.Interface; +using Deconstruction.Manager; +using Deconstruction.Tool; +using Deconstruction.Type; +using Deconstruction.Type.DMToolSlot; +using Deconstruction.Type.Linkable; +using SerializerHelper.Type; +using UnityEngine; +using UnityEngine.Pool; +using XericLibrary.Runtime.MacroLibrary; +using XericLibrary.Runtime.Nav; + +namespace SesothoLine +{ + /// + /// ·ƹ + /// + public class SesothoArrangementWiresTool : DecisionMakerToolBase + { + #region ¼ί + + /// + /// гԱί + /// + public delegate void ToolMemberChange(PlacementBase obj); + + /// + /// гԱ¼ + /// + public event ToolMemberChange OnAdditional; + + /// + /// гԱƳ¼ + /// + public event ToolMemberChange OnDecreasing; + + /// + /// Ԫ + /// + public event ToolMemberChange OnAnyVivification; + + /// + /// Ԫ + /// + public event ToolMemberChange OnAnyDormancy; + + #endregion + + #region ݼ + + /* + * 1 ǿֱ + * 2,3 ԲĽǶΪ90180 + * R תԲ + * shift+b Զ + * shift+n + */ + + /// + /// ǿֱ + /// + public static KeyPack OpKey_ForceStr = new KeyPack(KeyCode.Alpha1); + /// + /// ǿ90Բ + /// + public static KeyPack OpKey_90Arc = new KeyPack(KeyCode.Alpha2); + /// + /// ǿ180Բ + /// + public static KeyPack OpKey_180Arc = new KeyPack(KeyCode.Alpha3); + /// + /// ת˳򣬱絥Բķת + /// ˵shift+alt+rӢΰһݼأеͻ + /// + public static KeyPack OpKey_RevCisoid = new KeyPack(KeyCode.R); + /// + /// + /// + public static KeyPack OpKey_IgnoreNeighborAdsorption = new KeyPack(KeyCode.LeftShift, KeyCode.B); + /// + /// + /// + public static KeyPack OpKey_IgnoreGridAdsorption = new KeyPack(KeyCode.LeftShift, KeyCode.N); + + #endregion + + #region ֶ + + private ObjectPool _linePool; + private ObjectPool _pointPool; + + #endregion + + #region ȡת + + /// + /// ȡĶΪ + /// + /// + /// + public static bool GetNearestObjectAsPoint(out TerminalPoint point) + { + if (SesothoPeManager.NearestObject is not null && + SesothoPeManager.NearestObject is TerminalPoint terminalPoint) + { + point = terminalPoint; + return true; + } + point = null; + return false; + } + + /// + /// ȡĶΪ + /// + /// + /// + public static bool GetNearestObjectAsLine(out TerminalLine2T3 line) + { + if (SesothoPeManager.NearestObject is not null && + SesothoPeManager.NearestObject is TerminalPoint terminalPoint && + terminalPoint.LinkedData.GetOpposite(LinkType.Export) is TerminalLine2T3 terminalLine) + { + line = terminalLine; + return true; + } + line = null; + return false; + } + + /// + /// ȡԸ + /// + /// + /// + /// + /// + public static bool GetNearestObjectAsLine(TerminalPoint point, out TerminalLine2T3 line, out Vector3 normal) + { + if (point is null) + goto End; + // ǷЧǷ + if (SesothoPeManager.NearestLineTangentObject is TerminalLine2T3 otherLine && + point.TryGetLinkLineNormal(otherLine, out normal)) + { + line = otherLine; + return true; + } + + End: + line = null; + normal = default; + return false; + } + + #endregion + + #region + + protected override void Awake() + { + base.Awake(); + + _linePool = new ObjectPool( + createFunc: CreatElement, + actionOnGet: ElementActive, + actionOnRelease: ElementInactive, + actionOnDestroy: a => + { }, + collectionCheck: true, + defaultCapacity: 10, + maxSize: 10000); + + _pointPool = new ObjectPool( + createFunc: CreatElement, + actionOnGet: ElementActive, + actionOnRelease: ElementInactive, + actionOnDestroy: a => + { }, + collectionCheck: true, + defaultCapacity: 10, + maxSize: 10000); + + } + + protected override void OnEnableTool() + { + // ʱһȴΪΪ + var target = GenerateOperateSlot(); + target.InitializeNextTodo(() => new DrawTerminalLine2T3_OpSlot()); + + Debug.Log("·ƹ"); + } + + protected override void OnDisableTool() + { + + } + + protected override void OnFinalEnd() + { + base.OnFinalEnd(); + EnableTool = false; + } + + #endregion + + #region л + + public override SerializeUnion ToolSerializeDispost() + { + base.ToolSerializeDispost(); + foreach (var element in PlaceElementManager.Inst.StructuralLinkedList) + { + var union = element.SerializedOccurs(); + // Ǻʶ + union.Index = TypeConsignMap.AddMapIndex(element.GetType()); + union.RefreshSerializedContext(); + SerializeTemp.Add(union); + } + SerializeTemp.RefreshSerializedContext(); + return SerializeTemp; + } + + public override bool ToolDiserializDispost(SerializeUnion context) + { + if (!base.ToolDiserializDispost(context)) + return false; + + var deserializeList = new List<(PlacementBase, SerializeUnion)>(); + var safeCount = ushort.MaxValue; + Debug.Log("л̿ʼ"); + while (0 <-- safeCount && SerializeTemp.IndexMoveToNext(out var block)) + { + var union = SerializeTemp.GetDeserializeObject(); + var type = TypeConsignMap.GetMapType(union.Index); + if (GetElement(type, out var obj)) + { + deserializeList.Add((obj, union)); + union.RefreshDeserializeContext(); + union.IndexMoveToStart(); + obj.DeserializeOccurs(union); + // switch (obj) + // { + // case TerminalLine2T3 line: + // line.DeserializeOccurs(union); + // break; + // case TerminalPoint point: + // point.DeserializeOccurs(union); + // break; + // } + } + else + Debug.LogError($"޷лԪأԭͲ֧{type}"); + + if (block) break; + } + Debug.Log("л̿ʼָӹϵ"); + foreach (var item in deserializeList) + item.Item1.DeserializeHysteresisOccurs(item.Item2); + + return true; + } + + #endregion + + #region + + /// + /// Ԫ + /// + /// + private T CreatElement() + where T : PlacementBase, ILinkconfidentPe + { + var obj = CreatPlacementObject(); + obj.OnPlancementDestory += a => + { + if (a is null) + { + Debug.LogError("ԪѾ٣޷Ԫ"); + return; + } + if (a is T b && + b.GetLinkedNode(out var node)) + SesothoPeManager.Inst.RemoveLinkedTarget(node); + else + Debug.LogError("ԪزǹԪͣеڵѶʧ޷Ԫ"); + }; + return obj; + } + + /// + /// ض󼤻 + /// + /// + /// + private void ElementActive(T obj) + where T : PlacementBase, ILinkconfidentPe + { + obj.gameObject.SetActive(true); + OnAnyVivification?.Invoke(obj); + } + + /// + /// ضȡ + /// + /// + /// + private void ElementInactive(T obj) + where T : PlacementBase, ILinkconfidentPe + { + obj.gameObject.SetActive(false); + OnAnyDormancy?.Invoke(obj); + } + + /// + /// ȡԪ + /// + /// + public bool GetElement(out T obj) + where T : PlacementBase, ILinkconfidentPe + { + var name = typeof(T).Name; + switch (name) + { + case nameof(TerminalLine2T3): + obj = _linePool.Get() as T; + return true; + case nameof(TerminalPoint): + obj = _pointPool.Get() as T; + return true; + default: + Debug.LogError($"Ԫ({name})Ԥڣ⽫ع"); + break; + } + obj = null; + return false; + } + + /// + /// ȡԪ + /// + /// + /// + /// + public bool GetElement(Type type, out PlacementBase obj) + { + var name = type.Name; + switch (name) + { + case nameof(TerminalLine2T3): + obj = _linePool.Get(); + return true; + case nameof(TerminalPoint): + obj = _pointPool.Get(); + return true; + default: + Debug.LogError($"Ԫ({name})Ԥڣ⽫ع"); + break; + } + obj = null; + return false; + } + + + /// + /// ɾԪ + /// + /// + /// + public void DeleteElement(T obj) + where T : PlacementBase, + ILinkconfidentPe + { + var name = typeof(T).Name; + switch (name) + { + case nameof(TerminalLine2T3): + _linePool.Release(obj as TerminalLine2T3); + break; + case nameof(TerminalPoint): + _pointPool.Release(obj as TerminalPoint); + break; + default: + Debug.LogError($"Ԫ({name})Ԥڣ⽫ع"); + break; + } + } + + + + /// + /// Ԫڴ̬ԪغҪִеIJ (עⲻڴ̱) + /// + /// һߣôӦõ AddBulkLineToNeighborGrid; + /// һ㣬ôӦõ AddPeToNeighborGrid + /// + /// + public void PersistentElement(T obj) + where T : PlacementBase, + ILinkconfidentPe + { + // ṹҲڵ㣬ں + var lineNode = SesothoPeManager.Inst.AddLinkedTarget(obj); + obj.SetLinkedNode(lineNode); + } + + /// + /// ƳԪ + /// + /// + /// + public void ExcisionElement(T obj) + where T : PlacementBase, + ILinkconfidentPe + { + if (obj.GetLinkedNode(out var node)) + SesothoPeManager.Inst.RemoveLinkedTarget(node); + } + + + /// + /// СԪص + /// + /// + /// + public void AddPeToNeighborGrid(T obj) + where T : PlacementBase, + ILinkconfidentPe + { + if (obj.NeighborGridIndex != null) + { + Debug.LogError("޷ظԪأǰвĵԪأѾڣ˳ԡ"); + return; + } + SesothoPeManager.Inst.InsertNeighbor(obj, out var index); + obj.NeighborGridIndex = index; + + // ص¼ + OnAdditional?.Invoke(obj); + } + + /// + /// ӴԪص + /// + public void AddBulkPeToNeighborGrid(T obj) + where T : PlacementBase, + ILinkconfidentPe, + IPossessorTrajectory2 + { + if (obj.NeighborGridIndex != null) + { + Debug.LogError("޷ظԪأǰвĵԪأѾڣ˳ԡ"); + return; + } + SesothoPeManager.Inst.InsertGiantNeighbor(obj, out var index); + obj.NeighborGridIndex = index; + + // ص¼ + OnAdditional?.Invoke(obj); + } + + /// + /// ƳСԪ + /// + /// + /// + public void RemovePeToNeighborGrid(T obj) + where T : PlacementBase, + ILinkconfidentPe + { + if (obj.NeighborGridIndex != null && + obj.NeighborGridIndex.GetAsIndex(out var index)) + SesothoPeManager.Inst.RemoveNeighbor(index); + else + SesothoPeManager.Inst.RemoveNeighbor(obj); + ExcisionElement(obj); + // ص¼ + OnDecreasing?.Invoke(obj); + } + + /// + /// ƳԪ + /// + public void RemoveBulkPeFormNeighborGrid(T obj) + where T : PlacementBase, + ILinkconfidentPe, + IPossessorTrajectory2 + { + if (obj.NeighborGridIndex != null && + obj.NeighborGridIndex.GetAsMappingIndex(out var index)) + SesothoPeManager.Inst.RemoveGiantNeighbor(index); + else + SesothoPeManager.Inst.RemoveGiantNeighbor(obj); + ExcisionElement(obj); + // ص¼ + OnDecreasing?.Invoke(obj); + } + + #endregion + + #region Ѱ· + + /* + * ûд꣬鷳ԿAstart࣬Լʵ֡ + * + * Ҫṩ·ʱĶϣϰ + */ + + /// + /// ȡһͨ· + /// + /// һֻϵĶάƽЧ· + /// Ѱ·Ĺǽܿ̰㷨 + /// + /// + /// + /// յ + /// ð뾶ײʱط˻ + public DrawWayPoints GetPassThroughRouteShortcut(Vector3 startPoint, Vector3 endPoint, float avoidRadius) + { + var result = new DrawWayPoints(); + Debug.LogError("˷δ"); + return result; + } + + /// + /// ȡһͨ·ĵ + /// + /// + /// յ + /// ð뾶ϰʱط˻ + /// ײIJ + /// + protected IEnumerable GetPassThroughRoute(Vector3 startPoint, Vector3 endPoint, float avoidRadius, LayerMask layer) + { + yield return Vector3.zero; + } + + /// + /// ʹø·һιϵ· + /// + /// һ· + public void BuildPaths(DrawWayPoints wayPoints) + { + new AStart2(); + } + + #endregion + } +} diff --git a/Runtime/HorizonLineOrbit/SesothoPeManager.cs b/Runtime/HorizonLineOrbit/SesothoPeManager.cs new file mode 100644 index 0000000..0ae6d35 --- /dev/null +++ b/Runtime/HorizonLineOrbit/SesothoPeManager.cs @@ -0,0 +1,187 @@ +#define _DEBUG_ +// #undef _DEBUG_ + +using System; +using System.Collections; +using System.Collections.Generic; +using System.Linq; +using Deconstruction.Element; +using UnityEngine; + +using Deconstruction.Manager; +using Deconstruction.Tool; +using Deconstruction.Type.Area; +using Deconstruction.Type.Serialize; +using Newtonsoft.Json; +using SerializerHelper.Type; +using UnityEngine.UI; +using XericLibrary.Runtime.Debuger; +using XericLibrary.Runtime.MacroLibrary; + +namespace SesothoLine +{ + /// + /// Ҫ + /// + /// װ + /// + /// + public sealed class SesothoPeManager : PlaceElementManager + { + #region ̬Ա + + /// + /// ˴ṩĵ븸൥Ƕ + /// + public new static SesothoPeManager Inst => _inst; + private static SesothoPeManager _inst; + + /// + /// ·ƹ + /// + public static SesothoArrangementWiresTool WiresTool => _wiresTool; + private static SesothoArrangementWiresTool _wiresTool; + + /// + /// Ͻ + /// + public static Vector3 NearestLineTangentPoint => _lineTangentTraceTool.NearsetPoint; + /// + /// + /// + public static PlacementBase NearestLineTangentObject => _lineTangentTraceTool.NearsetObject; + /// + /// Ķԭ + /// + public static Vector3 NearestPoint => TrackingTool.TrackingCurrentPosition; + /// + /// Ķ + /// + public static PlacementBase NearestObject => TrackingTool.TrackingCurrentTarget; + + private static TrajectoryTrackingTool.TrackPersistentCommunicate _lineTangentTraceTool; + + #endregion + + #region Թ + +#if UNITY_EDITOR + + public bool EnableGridDebugDraw = false; + + + public void DebugFunc() + { + if (EnableGridDebugDraw) + { + PlacementNeighbor.DebugDrawGrid(); + } + } + +#endif + + #endregion + + #region + + protected override void Awake() + { + base.Awake(); + _inst = this; + + if (LineMaterial == null) + Debug.LogError("Ҫṩһ߶β"); + if (PointMaterial == null) + Debug.LogError("Ҫṩһ"); + + // ʼ߹ + _wiresTool = new SesothoArrangementWiresTool(); + _wiresTool.InitializeParent(transform); + + _lineTangentTraceTool = TrackingTool.InstantiationTrackCaculate(PlaceholdersAreaType.LinearContinuity); + + // ֶ + EnableUpdate = true; + + + } + + protected override void Start() + { + base.Start(); + } + + private NeighborGrid.NeighborGridIndex index; + protected override void Update() + { + base.Update(); +#if UNITY_EDITOR + DebugFunc(); +#endif + if (Input.GetMouseButtonDown(2)) + { + index = PlacementNeighbor.GetNeighborIndex(null); + index.SetDrivenAsWorld(InputHelper.CurrentPosition); + Debug.Log($"{index.GetDrivenAsLinear()} => {index.GetNeighbor().FirstOrDefault()}"); + } + + // new SerializeUnion(); + } + + private string serializeContext = null; + protected override void LateUpdate() + { + base.LateUpdate(); + // if (DecisionMakerToolBase.ActiveDecisionMaker == null || + // !DecisionMakerToolBase.ActiveDecisionMaker.EnableTool) +#if !UNITY_EDITOR || !_DEBUG_ + return; +#endif + // ߹ܲ + if (Input.GetKeyDown(KeyCode.L)) + { + _wiresTool.EnableTool = !_wiresTool.EnableTool; + Debug.Log($"{(_wiresTool.EnableTool ? "ƹѼ" : "ȡ")}"); + } + + // 浵ܲ + if (Input.GetKeyDown(KeyCode.S)) + { + var obj = _wiresTool.ToolSerializeDispost(); + serializeContext = JsonConvert.SerializeObject(obj); + Debug.Log(obj.ToString()); + } + if (Input.GetKeyDown(KeyCode.D)) + { + if (serializeContext == null) + { + Debug.Log("лΪ"); + return; + } + + var obj = JsonConvert.DeserializeObject(serializeContext); + _wiresTool.ToolDiserializDispost(obj); + } + + if (Input.GetKeyDown(KeyCode.A)) + { + _wiresTool.EnableCompress = !_wiresTool.EnableCompress; + if (_wiresTool.EnableCompress ) + Debug.Log("ѹ"); + else + Debug.Log("رѹ"); + } + + + // һĿλ + if (TrackingTool.EnableTool || TrackingTool._enableAuxiliaryTool) + { + MacroDebugDraw.DrawDownArrow(NearestPoint, Color.magenta); + MacroDebugDraw.DrawDownArrow(NearestLineTangentPoint, Color.green); + } + } + + #endregion + + } +} diff --git a/Runtime/HorizonLineOrbit/TerminalLine2T3.cs b/Runtime/HorizonLineOrbit/TerminalLine2T3.cs new file mode 100644 index 0000000..8cffa6d --- /dev/null +++ b/Runtime/HorizonLineOrbit/TerminalLine2T3.cs @@ -0,0 +1,224 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Runtime.Serialization; +using System.Runtime.Serialization.Formatters.Binary; +using System.Text; +using Deconstruction.Element; +using Deconstruction.Interface; + +#if UNITY_EDITOR +using UnityEditor; +#endif + +using UnityEngine; +using UnityEngine.Serialization; +using XericLibrary.Runtime.Debuger; +using XericLibrary.Runtime.MacroLibrary; +using XericLibrary.Runtime.Type; + +namespace SesothoLine +{ + + using LineSegment2 = Deconstruction.Element.PromptLine2.LineSegment2; + + /// + /// նִнűʹöά߼άȾ + /// + public class TerminalLine2T3 : PromptLine2, + ILinkconfidentPe // + { + #region ֶ + + private LinkedListNode _linkNode; + + /// + /// ػ + /// + private LineSegment2 _lineSegment = new LineSegment2(); + + public bool DebugDrawGrid = false; + + #endregion + + #region + + protected override void Start() + { + base.Start(); + InitPromptLine(); + } + + protected override void OnEnable() + { + base.OnEnable(); + SesothoPeManager.Inst.AddEmbedded(this); + } + + protected override void OnDisable() + { + base.OnDisable(); + SesothoPeManager.Inst.RemoveEmbedded(this); + } + + protected virtual void OnDestroy() + { + + } + + protected override void AgencyOnEnable() + { + base.AgencyOnEnable(); + } + + protected override void AgencyOnDisable() + { + base.AgencyOnDisable(); + } + + protected override void AgencyMainUpdate() + { + base.AgencyMainUpdate(); + + // ·еλ + if (DebugDrawGrid && + NeighborGridIndex.SafeGetAsMappingIndex(out var indexs)) + { + foreach (var index in indexs.Indexs) + { + MacroDebugDraw.DrawDownArrow( + index.GetCellWorldIndexPosition() + MacroMath.RandomVector3(0.1f, Identifier), + Color.red); + } + } + + } + + protected override void AgencyAsyncBeforeUpdate() + { + base.AgencyAsyncBeforeUpdate(); + } + + protected override void AgencyAsyncUpdate() + { + base.AgencyAsyncUpdate(); + } + + protected override void AgencyAsyncAfterUpdate() + { + base.AgencyAsyncAfterUpdate(); + } + + #endregion + + #region · + + /// + /// ռ + /// + /// + /// + /// + /// + /// + public LineSegment2 SetLineSegment(Vector3 a, Vector3 b, Vector3 ah = default, Vector3 bh = default) + { + _lineSegment.SetValue( + a.UpwardPlaneToVector2(), + b.UpwardPlaneToVector2(), + ah.UpwardPlaneToVector2(), + bh.UpwardPlaneToVector2()); + // ah?.GetEndPointNormal ?? default, + // bh?.GetStartPointNormal ?? default); + return _lineSegment; + } + + public void AutomaticDrawCircularLine(float constraintAngle = -1, bool fullArc = false) + { + AutomaticDrawCircularLine(_lineSegment, constraintAngle, fullArc); + } + + private LineSegment2 straightLine = new LineSegment2(); + public void DrawStraightLine() + { + straightLine.SetValue(_lineSegment.pointA, _lineSegment.pointB); + AutomaticDrawCircularLine(straightLine); + } + + + /// + /// ¼ԭ + /// + /// ˹켣ԭ㣬ôͨ˷Խԭõյ֮䡣 + /// ע⣺ʹǰҪ켣Ϊ + /// + /// + public void ReapplyOrigin() + { + if (TrajectoryRenderer == null || TrajectoryCalculator == null) + { + Debug.LogError("ǰ켣ȾЧ޷ԭ"); + return; + } + + // ٶеĹ켣DZ + + // ı + var center = ((TrajectoryCalculator.GetStartPointPosition + TrajectoryCalculator.GetEndPointPosition) / 2).UpwardPlaneToVector3(); + // ԭ + var local = TrajectoryCalculator.Origin.UpwardPlaneToVector3(); + // ƫ + var offset = local - center; + + TrajectoryCalculator.Origin = offset.UpwardPlaneToVector2(); + transform.position += center; + + // + UpdateRender(); + } + + #endregion + + #region ʵ - ILinkconfidentPe + + public bool GetLinkedNode(out LinkedListNode node) + { + if (_linkNode == null) + { + node = null; + return false; + } + + node = _linkNode; + return true; + } + + public void SetLinkedNode(LinkedListNode node) + { + _linkNode = node; + } + + #endregion + + #region д - ISerializablePost + + public override SerializerHelper.Type.SerializeUnion SerializedOccurs() + { + return base.SerializedOccurs(); + } + public override bool CheckDeserializeUnion(SerializerHelper.Type.SerializeUnion context) + { + return base.CheckDeserializeUnion(context); + } + public override void DeserializeOccurs(SerializerHelper.Type.SerializeUnion context) + { + base.DeserializeOccurs(context); + } + public override void DeserializeHysteresisOccurs(SerializerHelper.Type.SerializeUnion context) + { + base.DeserializeHysteresisOccurs(context); + } + + #endregion + } +} diff --git a/Runtime/HorizonLineOrbit/TerminalPoint.cs b/Runtime/HorizonLineOrbit/TerminalPoint.cs new file mode 100644 index 0000000..9549ec4 --- /dev/null +++ b/Runtime/HorizonLineOrbit/TerminalPoint.cs @@ -0,0 +1,72 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using Deconstruction.Element; +using UnityEngine; +using XericLibrary.Runtime.Debuger; +using XericLibrary.Runtime.MacroLibrary; +using Random = System.Random; + +namespace SesothoLine +{ + /// + /// 㣬еӵ + /// + public class TerminalPoint : Deconstruction.Element.ContactPoint, + ILinkconfidentPe // + { + private LinkedListNode _linkNode; + + #region + + // Իһλ + // private void Update() + // { + // MacroDebugDraw.DrawDownArrow(transform.position + MacroMath.RandomVector3(0.1f, Identifier), Color.green); + // } + + #endregion + + #region ʵ - ILinkconfidentPe + + public bool GetLinkedNode(out LinkedListNode node) + { + if (_linkNode == null) + { + node = null; + return false; + } + + node = _linkNode; + return true; + } + + public void SetLinkedNode(LinkedListNode node) + { + _linkNode = node; + } + + #endregion + + #region д - ISerializablePost + + public override SerializerHelper.Type.SerializeUnion SerializedOccurs() + { + return base.SerializedOccurs(); + } + public override bool CheckDeserializeUnion(SerializerHelper.Type.SerializeUnion context) + { + return base.CheckDeserializeUnion(context); + } + public override void DeserializeOccurs(SerializerHelper.Type.SerializeUnion context) + { + base.DeserializeOccurs(context); + } + public override void DeserializeHysteresisOccurs(SerializerHelper.Type.SerializeUnion context) + { + base.DeserializeHysteresisOccurs(context); + } + + #endregion + } +} diff --git a/Runtime/Lrss3.Deconstruction.asmdef b/Runtime/Lrss3.Deconstruction.asmdef new file mode 100644 index 0000000..60f5425 --- /dev/null +++ b/Runtime/Lrss3.Deconstruction.asmdef @@ -0,0 +1,16 @@ +{ + "name": "Lrss3.Deconstruction", + "rootNamespace": "Deconstruction", + "references": [ + "GUID:6055be8ebefd69e48b49212b09b47b2f" + ], + "includePlatforms": [], + "excludePlatforms": [], + "allowUnsafeCode": false, + "overrideReferences": false, + "precompiledReferences": [], + "autoReferenced": true, + "defineConstraints": [], + "versionDefines": [], + "noEngineReferences": false +} \ No newline at end of file diff --git a/Runtime/MathNet.Numerics.xml b/Runtime/MathNet.Numerics.xml new file mode 100644 index 0000000..3d573a1 --- /dev/null +++ b/Runtime/MathNet.Numerics.xml @@ -0,0 +1,53733 @@ + + + + MathNet.Numerics + + + + + AppContext based switches to disable functionality, controllable through also in the + host application through AppContext or by configuration with AppContextSwitchOverride. + https://docs.microsoft.com/en-us/dotnet/framework/configure-apps/file-schema/runtime/appcontextswitchoverrides-element + + + Since AppContext is not supported on .NET Framework 4.0, a local implementation is used there instead, + which cannot be controlled though configuration or through AppContext. + + + + + Useful extension methods for Arrays. + + + + + Copies the values from on array to another. + + The source array. + The destination array. + + + + Copies the values from on array to another. + + The source array. + The destination array. + + + + Copies the values from on array to another. + + The source array. + The destination array. + + + + Copies the values from on array to another. + + The source array. + The destination array. + + + + Enumerative Combinatorics and Counting. + + + + + Count the number of possible variations without repetition. + The order matters and each object can be chosen only once. + + Number of elements in the set. + Number of elements to choose from the set. Each element is chosen at most once. + Maximum number of distinct variations. + + + + Count the number of possible variations with repetition. + The order matters and each object can be chosen more than once. + + Number of elements in the set. + Number of elements to choose from the set. Each element is chosen 0, 1 or multiple times. + Maximum number of distinct variations with repetition. + + + + Count the number of possible combinations without repetition. + The order does not matter and each object can be chosen only once. + + Number of elements in the set. + Number of elements to choose from the set. Each element is chosen at most once. + Maximum number of combinations. + + + + Count the number of possible combinations with repetition. + The order does not matter and an object can be chosen more than once. + + Number of elements in the set. + Number of elements to choose from the set. Each element is chosen 0, 1 or multiple times. + Maximum number of combinations with repetition. + + + + Count the number of possible permutations (without repetition). + + Number of (distinguishable) elements in the set. + Maximum number of permutations without repetition. + + + + Generate a random permutation, without repetition, by generating the index numbers 0 to N-1 and shuffle them randomly. + Implemented using Fisher-Yates Shuffling. + + An array of length N that contains (in any order) the integers of the interval [0, N). + Number of (distinguishable) elements in the set. + The random number generator to use. Optional; the default random source will be used if null. + + + + Select a random permutation, without repetition, from a data array by reordering the provided array in-place. + Implemented using Fisher-Yates Shuffling. The provided data array will be modified. + + The data array to be reordered. The array will be modified by this routine. + The random number generator to use. Optional; the default random source will be used if null. + + + + Select a random permutation from a data sequence by returning the provided data in random order. + Implemented using Fisher-Yates Shuffling. + + The data elements to be reordered. + The random number generator to use. Optional; the default random source will be used if null. + + + + Generate a random combination, without repetition, by randomly selecting some of N elements. + + Number of elements in the set. + The random number generator to use. Optional; the default random source will be used if null. + Boolean mask array of length N, for each item true if it is selected. + + + + Generate a random combination, without repetition, by randomly selecting k of N elements. + + Number of elements in the set. + Number of elements to choose from the set. Each element is chosen at most once. + The random number generator to use. Optional; the default random source will be used if null. + Boolean mask array of length N, for each item true if it is selected. + + + + Select a random combination, without repetition, from a data sequence by selecting k elements in original order. + + The data source to choose from. + Number of elements (k) to choose from the data set. Each element is chosen at most once. + The random number generator to use. Optional; the default random source will be used if null. + The chosen combination, in the original order. + + + + Generates a random combination, with repetition, by randomly selecting k of N elements. + + Number of elements in the set. + Number of elements to choose from the set. Elements can be chosen more than once. + The random number generator to use. Optional; the default random source will be used if null. + Integer mask array of length N, for each item the number of times it was selected. + + + + Select a random combination, with repetition, from a data sequence by selecting k elements in original order. + + The data source to choose from. + Number of elements (k) to choose from the data set. Elements can be chosen more than once. + The random number generator to use. Optional; the default random source will be used if null. + The chosen combination with repetition, in the original order. + + + + Generate a random variation, without repetition, by randomly selecting k of n elements with order. + Implemented using partial Fisher-Yates Shuffling. + + Number of elements in the set. + Number of elements to choose from the set. Each element is chosen at most once. + The random number generator to use. Optional; the default random source will be used if null. + An array of length K that contains the indices of the selections as integers of the interval [0, N). + + + + Generate a random variation, without repetition, by randomly selecting k of n elements with order. This is an O(k) space-complexity implementation optimized for very large N.
    + The space complexity of Fisher-Yates Shuffling is O(n+k). When N is very large, the algorithm will be unexecutable in limited memory, and a more memory-efficient algorithm is needed.
    + You can explicitly cast N to if N is out of range of or memory, so that this special implementation is called. However, this implementation is slower than Fisher-Yates Shuffling: don't call it if time is more critical than space.
    + The K of type seems impossible, because the returned array is of size K and must all be stored in memory. +     + Number of elements in the set. + Number of elements to choose from the set. Each element is chosen at most once. + The random number generator to use. Optional; the default random source will be used if null. + An array of length K that contains the indices of the selections as integers of the interval [0, N). +     + + + Select a random variation, without repetition, from a data sequence by randomly selecting k elements in random order. + Implemented using partial Fisher-Yates Shuffling. + + The data source to choose from. + Number of elements (k) to choose from the set. Each element is chosen at most once. + The random number generator to use. Optional; the default random source will be used if null. + The chosen variation, in random order. + + + + Generate a random variation, with repetition, by randomly selecting k of n elements with order. + + Number of elements in the set. + Number of elements to choose from the set. Elements can be chosen more than once. + The random number generator to use. Optional; the default random source will be used if null. + An array of length K that contains the indices of the selections as integers of the interval [0, N). + + + + Select a random variation, with repetition, from a data sequence by randomly selecting k elements in random order. + + The data source to choose from. + Number of elements (k) to choose from the data set. Elements can be chosen more than once. + The random number generator to use. Optional; the default random source will be used if null. + The chosen variation with repetition, in random order. + + + + 32-bit single precision complex numbers class. + + + + The class Complex32 provides all elementary operations + on complex numbers. All the operators +, -, + *, /, ==, != are defined in the + canonical way. Additional complex trigonometric functions + are also provided. Note that the Complex32 structures + has two special constant values and + . + + + + Complex32 x = new Complex32(1f,2f); + Complex32 y = Complex32.FromPolarCoordinates(1f, Math.Pi); + Complex32 z = (x + y) / (x - y); + + + + For mathematical details about complex numbers, please + have a look at the + Wikipedia + + + + + + The real component of the complex number. + + + + + The imaginary component of the complex number. + + + + + Initializes a new instance of the Complex32 structure with the given real + and imaginary parts. + + The value for the real component. + The value for the imaginary component. + + + + Creates a complex number from a point's polar coordinates. + + A complex number. + The magnitude, which is the distance from the origin (the intersection of the x-axis and the y-axis) to the number. + The phase, which is the angle from the line to the horizontal axis, measured in radians. + + + + Returns a new instance + with a real number equal to zero and an imaginary number equal to zero. + + + + + Returns a new instance + with a real number equal to one and an imaginary number equal to zero. + + + + + Returns a new instance + with a real number equal to zero and an imaginary number equal to one. + + + + + Returns a new instance + with real and imaginary numbers positive infinite. + + + + + Returns a new instance + with real and imaginary numbers not a number. + + + + + Gets the real component of the complex number. + + The real component of the complex number. + + + + Gets the real imaginary component of the complex number. + + The real imaginary component of the complex number. + + + + Gets the phase or argument of this Complex32. + + + Phase always returns a value bigger than negative Pi and + smaller or equal to Pi. If this Complex32 is zero, the Complex32 + is assumed to be positive real with an argument of zero. + + The phase or argument of this Complex32 + + + + Gets the magnitude (or absolute value) of a complex number. + + Assuming that magnitude of (inf,a) and (a,inf) and (inf,inf) is inf and (NaN,a), (a,NaN) and (NaN,NaN) is NaN + The magnitude of the current instance. + + + + Gets the squared magnitude (or squared absolute value) of a complex number. + + The squared magnitude of the current instance. + + + + Gets the unity of this complex (same argument, but on the unit circle; exp(I*arg)) + + The unity of this Complex32. + + + + Gets a value indicating whether the Complex32 is zero. + + true if this instance is zero; otherwise, false. + + + + Gets a value indicating whether the Complex32 is one. + + true if this instance is one; otherwise, false. + + + + Gets a value indicating whether the Complex32 is the imaginary unit. + + true if this instance is ImaginaryOne; otherwise, false. + + + + Gets a value indicating whether the provided Complex32evaluates + to a value that is not a number. + + + true if this instance is ; otherwise, + false. + + + + + Gets a value indicating whether the provided Complex32 evaluates to an + infinite value. + + + true if this instance is infinite; otherwise, false. + + + True if it either evaluates to a complex infinity + or to a directed infinity. + + + + + Gets a value indicating whether the provided Complex32 is real. + + true if this instance is a real number; otherwise, false. + + + + Gets a value indicating whether the provided Complex32 is real and not negative, that is >= 0. + + + true if this instance is real nonnegative number; otherwise, false. + + + + + Exponential of this Complex32 (exp(x), E^x). + + + The exponential of this complex number. + + + + + Natural Logarithm of this Complex32 (Base E). + + The natural logarithm of this complex number. + + + + Common Logarithm of this Complex32 (Base 10). + + The common logarithm of this complex number. + + + + Logarithm of this Complex32 with custom base. + + The logarithm of this complex number. + + + + Raise this Complex32 to the given value. + + + The exponent. + + + The complex number raised to the given exponent. + + + + + Raise this Complex32 to the inverse of the given value. + + + The root exponent. + + + The complex raised to the inverse of the given exponent. + + + + + The Square (power 2) of this Complex32 + + + The square of this complex number. + + + + + The Square Root (power 1/2) of this Complex32 + + + The square root of this complex number. + + + + + Evaluate all square roots of this Complex32. + + + + + Evaluate all cubic roots of this Complex32. + + + + + Equality test. + + One of complex numbers to compare. + The other complex numbers to compare. + true if the real and imaginary components of the two complex numbers are equal; false otherwise. + + + + Inequality test. + + One of complex numbers to compare. + The other complex numbers to compare. + true if the real or imaginary components of the two complex numbers are not equal; false otherwise. + + + + Unary addition. + + The complex number to operate on. + Returns the same complex number. + + + + Unary minus. + + The complex number to operate on. + The negated value of the . + + + Addition operator. Adds two complex numbers together. + The result of the addition. + One of the complex numbers to add. + The other complex numbers to add. + + + Subtraction operator. Subtracts two complex numbers. + The result of the subtraction. + The complex number to subtract from. + The complex number to subtract. + + + Addition operator. Adds a complex number and float together. + The result of the addition. + The complex numbers to add. + The float value to add. + + + Subtraction operator. Subtracts float value from a complex value. + The result of the subtraction. + The complex number to subtract from. + The float value to subtract. + + + Addition operator. Adds a complex number and float together. + The result of the addition. + The float value to add. + The complex numbers to add. + + + Subtraction operator. Subtracts complex value from a float value. + The result of the subtraction. + The float vale to subtract from. + The complex value to subtract. + + + Multiplication operator. Multiplies two complex numbers. + The result of the multiplication. + One of the complex numbers to multiply. + The other complex number to multiply. + + + Multiplication operator. Multiplies a complex number with a float value. + The result of the multiplication. + The float value to multiply. + The complex number to multiply. + + + Multiplication operator. Multiplies a complex number with a float value. + The result of the multiplication. + The complex number to multiply. + The float value to multiply. + + + Division operator. Divides a complex number by another. + Enhanced Smith's algorithm for dividing two complex numbers + + The result of the division. + The dividend. + The divisor. + + + + Helper method for dividing. + + Re first + Im first + Re second + Im second + + + + + Division operator. Divides a float value by a complex number. + Algorithm based on Smith's algorithm + + The result of the division. + The dividend. + The divisor. + + + Division operator. Divides a complex number by a float value. + The result of the division. + The dividend. + The divisor. + + + + Computes the conjugate of a complex number and returns the result. + + + + + Returns the multiplicative inverse of a complex number. + + + + + Converts the value of the current complex number to its equivalent string representation in Cartesian form. + + The string representation of the current instance in Cartesian form. + + + + Converts the value of the current complex number to its equivalent string representation + in Cartesian form by using the specified format for its real and imaginary parts. + + The string representation of the current instance in Cartesian form. + A standard or custom numeric format string. + + is not a valid format string. + + + + Converts the value of the current complex number to its equivalent string representation + in Cartesian form by using the specified culture-specific formatting information. + + The string representation of the current instance in Cartesian form, as specified by . + An object that supplies culture-specific formatting information. + + + Converts the value of the current complex number to its equivalent string representation + in Cartesian form by using the specified format and culture-specific format information for its real and imaginary parts. + The string representation of the current instance in Cartesian form, as specified by and . + A standard or custom numeric format string. + An object that supplies culture-specific formatting information. + + is not a valid format string. + + + + Checks if two complex numbers are equal. Two complex numbers are equal if their + corresponding real and imaginary components are equal. + + + Returns true if the two objects are the same object, or if their corresponding + real and imaginary components are equal, false otherwise. + + + The complex number to compare to with. + + + + + The hash code for the complex number. + + + The hash code of the complex number. + + + The hash code is calculated as + System.Math.Exp(ComplexMath.Absolute(complexNumber)). + + + + + Checks if two complex numbers are equal. Two complex numbers are equal if their + corresponding real and imaginary components are equal. + + + Returns true if the two objects are the same object, or if their corresponding + real and imaginary components are equal, false otherwise. + + + The complex number to compare to with. + + + + + Creates a complex number based on a string. The string can be in the + following formats (without the quotes): 'n', 'ni', 'n +/- ni', + 'ni +/- n', 'n,n', 'n,ni,' '(n,n)', or '(n,ni)', where n is a float. + + + A complex number containing the value specified by the given string. + + + the string to parse. + + + An that supplies culture-specific + formatting information. + + + + + Parse a part (real or complex) from a complex number. + + Start Token. + Is set to true if the part identified itself as being imaginary. + + An that supplies culture-specific + formatting information. + + Resulting part as float. + + + + + Converts the string representation of a complex number to a single-precision complex number equivalent. + A return value indicates whether the conversion succeeded or failed. + + + A string containing a complex number to convert. + + + The parsed value. + + + If the conversion succeeds, the result will contain a complex number equivalent to value. + Otherwise the result will contain complex32.Zero. This parameter is passed uninitialized + + + + + Converts the string representation of a complex number to single-precision complex number equivalent. + A return value indicates whether the conversion succeeded or failed. + + + A string containing a complex number to convert. + + + An that supplies culture-specific formatting information about value. + + + The parsed value. + + + If the conversion succeeds, the result will contain a complex number equivalent to value. + Otherwise the result will contain complex32.Zero. This parameter is passed uninitialized + + + + + Explicit conversion of a real decimal to a Complex32. + + The decimal value to convert. + The result of the conversion. + + + + Explicit conversion of a Complex to a Complex32. + + The decimal value to convert. + The result of the conversion. + + + + Implicit conversion of a real byte to a Complex32. + + The byte value to convert. + The result of the conversion. + + + + Implicit conversion of a real short to a Complex32. + + The short value to convert. + The result of the conversion. + + + + Implicit conversion of a signed byte to a Complex32. + + The signed byte value to convert. + The result of the conversion. + + + + Implicit conversion of a unsigned real short to a Complex32. + + The unsigned short value to convert. + The result of the conversion. + + + + Implicit conversion of a real int to a Complex32. + + The int value to convert. + The result of the conversion. + + + + Implicit conversion of a BigInteger int to a Complex32. + + The BigInteger value to convert. + The result of the conversion. + + + + Implicit conversion of a real long to a Complex32. + + The long value to convert. + The result of the conversion. + + + + Implicit conversion of a real uint to a Complex32. + + The uint value to convert. + The result of the conversion. + + + + Implicit conversion of a real ulong to a Complex32. + + The ulong value to convert. + The result of the conversion. + + + + Implicit conversion of a real float to a Complex32. + + The float value to convert. + The result of the conversion. + + + + Implicit conversion of a real double to a Complex32. + + The double value to convert. + The result of the conversion. + + + + Converts this Complex32 to a . + + A with the same values as this Complex32. + + + + Returns the additive inverse of a specified complex number. + + The result of the real and imaginary components of the value parameter multiplied by -1. + A complex number. + + + + Computes the conjugate of a complex number and returns the result. + + The conjugate of . + A complex number. + + + + Adds two complex numbers and returns the result. + + The sum of and . + The first complex number to add. + The second complex number to add. + + + + Subtracts one complex number from another and returns the result. + + The result of subtracting from . + The value to subtract from (the minuend). + The value to subtract (the subtrahend). + + + + Returns the product of two complex numbers. + + The product of the and parameters. + The first complex number to multiply. + The second complex number to multiply. + + + + Divides one complex number by another and returns the result. + + The quotient of the division. + The complex number to be divided. + The complex number to divide by. + + + + Returns the multiplicative inverse of a complex number. + + The reciprocal of . + A complex number. + + + + Returns the square root of a specified complex number. + + The square root of . + A complex number. + + + + Gets the absolute value (or magnitude) of a complex number. + + The absolute value of . + A complex number. + + + + Returns e raised to the power specified by a complex number. + + The number e raised to the power . + A complex number that specifies a power. + + + + Returns a specified complex number raised to a power specified by a complex number. + + The complex number raised to the power . + A complex number to be raised to a power. + A complex number that specifies a power. + + + + Returns a specified complex number raised to a power specified by a single-precision floating-point number. + + The complex number raised to the power . + A complex number to be raised to a power. + A single-precision floating-point number that specifies a power. + + + + Returns the natural (base e) logarithm of a specified complex number. + + The natural (base e) logarithm of . + A complex number. + + + + Returns the logarithm of a specified complex number in a specified base. + + The logarithm of in base . + A complex number. + The base of the logarithm. + + + + Returns the base-10 logarithm of a specified complex number. + + The base-10 logarithm of . + A complex number. + + + + Returns the sine of the specified complex number. + + The sine of . + A complex number. + + + + Returns the cosine of the specified complex number. + + The cosine of . + A complex number. + + + + Returns the tangent of the specified complex number. + + The tangent of . + A complex number. + + + + Returns the angle that is the arc sine of the specified complex number. + + The angle which is the arc sine of . + A complex number. + + + + Returns the angle that is the arc cosine of the specified complex number. + + The angle, measured in radians, which is the arc cosine of . + A complex number that represents a cosine. + + + + Returns the angle that is the arc tangent of the specified complex number. + + The angle that is the arc tangent of . + A complex number. + + + + Returns the hyperbolic sine of the specified complex number. + + The hyperbolic sine of . + A complex number. + + + + Returns the hyperbolic cosine of the specified complex number. + + The hyperbolic cosine of . + A complex number. + + + + Returns the hyperbolic tangent of the specified complex number. + + The hyperbolic tangent of . + A complex number. + + + + Extension methods for the Complex type provided by System.Numerics + + + + + Gets the squared magnitude of the Complex number. + + The number to perform this operation on. + The squared magnitude of the Complex number. + + + + Gets the squared magnitude of the Complex number. + + The number to perform this operation on. + The squared magnitude of the Complex number. + + + + Gets the unity of this complex (same argument, but on the unit circle; exp(I*arg)) + + The unity of this Complex. + + + + Gets the conjugate of the Complex number. + + The number to perform this operation on. + + The semantic of setting the conjugate is such that + + // a, b of type Complex32 + a.Conjugate = b; + + is equivalent to + + // a, b of type Complex32 + a = b.Conjugate + + + The conjugate of the number. + + + + Returns the multiplicative inverse of a complex number. + + + + + Exponential of this Complex (exp(x), E^x). + + The number to perform this operation on. + + The exponential of this complex number. + + + + + Natural Logarithm of this Complex (Base E). + + The number to perform this operation on. + + The natural logarithm of this complex number. + + + + + Common Logarithm of this Complex (Base 10). + + The common logarithm of this complex number. + + + + Logarithm of this Complex with custom base. + + The logarithm of this complex number. + + + + Raise this Complex to the given value. + + The number to perform this operation on. + + The exponent. + + + The complex number raised to the given exponent. + + + + + Raise this Complex to the inverse of the given value. + + The number to perform this operation on. + + The root exponent. + + + The complex raised to the inverse of the given exponent. + + + + + The Square (power 2) of this Complex + + The number to perform this operation on. + + The square of this complex number. + + + + + The Square Root (power 1/2) of this Complex + + The number to perform this operation on. + + The square root of this complex number. + + + + + Evaluate all square roots of this Complex. + + + + + Evaluate all cubic roots of this Complex. + + + + + Gets a value indicating whether the Complex32 is zero. + + The number to perform this operation on. + true if this instance is zero; otherwise, false. + + + + Gets a value indicating whether the Complex32 is one. + + The number to perform this operation on. + true if this instance is one; otherwise, false. + + + + Gets a value indicating whether the Complex32 is the imaginary unit. + + true if this instance is ImaginaryOne; otherwise, false. + The number to perform this operation on. + + + + Gets a value indicating whether the provided Complex32evaluates + to a value that is not a number. + + The number to perform this operation on. + + true if this instance is NaN; otherwise, + false. + + + + + Gets a value indicating whether the provided Complex32 evaluates to an + infinite value. + + The number to perform this operation on. + + true if this instance is infinite; otherwise, false. + + + True if it either evaluates to a complex infinity + or to a directed infinity. + + + + + Gets a value indicating whether the provided Complex32 is real. + + The number to perform this operation on. + true if this instance is a real number; otherwise, false. + + + + Gets a value indicating whether the provided Complex32 is real and not negative, that is >= 0. + + The number to perform this operation on. + + true if this instance is real nonnegative number; otherwise, false. + + + + + Returns a Norm of a value of this type, which is appropriate for measuring how + close this value is to zero. + + + + + Returns a Norm of a value of this type, which is appropriate for measuring how + close this value is to zero. + + + + + Returns a Norm of the difference of two values of this type, which is + appropriate for measuring how close together these two values are. + + + + + Returns a Norm of the difference of two values of this type, which is + appropriate for measuring how close together these two values are. + + + + + Creates a complex number based on a string. The string can be in the + following formats (without the quotes): 'n', 'ni', 'n +/- ni', + 'ni +/- n', 'n,n', 'n,ni,' '(n,n)', or '(n,ni)', where n is a double. + + + A complex number containing the value specified by the given string. + + + The string to parse. + + + + + Creates a complex number based on a string. The string can be in the + following formats (without the quotes): 'n', 'ni', 'n +/- ni', + 'ni +/- n', 'n,n', 'n,ni,' '(n,n)', or '(n,ni)', where n is a double. + + + A complex number containing the value specified by the given string. + + + the string to parse. + + + An that supplies culture-specific + formatting information. + + + + + Parse a part (real or complex) from a complex number. + + Start Token. + Is set to true if the part identified itself as being imaginary. + + An that supplies culture-specific + formatting information. + + Resulting part as double. + + + + + Converts the string representation of a complex number to a double-precision complex number equivalent. + A return value indicates whether the conversion succeeded or failed. + + + A string containing a complex number to convert. + + + The parsed value. + + + If the conversion succeeds, the result will contain a complex number equivalent to value. + Otherwise the result will contain Complex.Zero. This parameter is passed uninitialized. + + + + + Converts the string representation of a complex number to double-precision complex number equivalent. + A return value indicates whether the conversion succeeded or failed. + + + A string containing a complex number to convert. + + + An that supplies culture-specific formatting information about value. + + + The parsed value. + + + If the conversion succeeds, the result will contain a complex number equivalent to value. + Otherwise the result will contain complex32.Zero. This parameter is passed uninitialized + + + + + Creates a Complex32 number based on a string. The string can be in the + following formats (without the quotes): 'n', 'ni', 'n +/- ni', + 'ni +/- n', 'n,n', 'n,ni,' '(n,n)', or '(n,ni)', where n is a double. + + + A complex number containing the value specified by the given string. + + + the string to parse. + + + + + Creates a Complex32 number based on a string. The string can be in the + following formats (without the quotes): 'n', 'ni', 'n +/- ni', + 'ni +/- n', 'n,n', 'n,ni,' '(n,n)', or '(n,ni)', where n is a double. + + + A complex number containing the value specified by the given string. + + + the string to parse. + + + An that supplies culture-specific + formatting information. + + + + + Converts the string representation of a complex number to a single-precision complex number equivalent. + A return value indicates whether the conversion succeeded or failed. + + + A string containing a complex number to convert. + + + The parsed value. + + + If the conversion succeeds, the result will contain a complex number equivalent to value. + Otherwise the result will contain complex32.Zero. This parameter is passed uninitialized. + + + + + Converts the string representation of a complex number to single-precision complex number equivalent. + A return value indicates whether the conversion succeeded or failed. + + + A string containing a complex number to convert. + + + An that supplies culture-specific formatting information about value. + + + The parsed value. + + + If the conversion succeeds, the result will contain a complex number equivalent to value. + Otherwise the result will contain Complex.Zero. This parameter is passed uninitialized. + + + + + A collection of frequently used mathematical constants. + + + + The number e + + + The number log[2](e) + + + The number log[10](e) + + + The number log[e](2) + + + The number log[e](10) + + + The number log[e](pi) + + + The number log[e](2*pi)/2 + + + The number 1/e + + + The number sqrt(e) + + + The number sqrt(2) + + + The number sqrt(3) + + + The number sqrt(1/2) = 1/sqrt(2) = sqrt(2)/2 + + + The number sqrt(3)/2 + + + The number pi + + + The number pi*2 + + + The number pi/2 + + + The number pi*3/2 + + + The number pi/4 + + + The number sqrt(pi) + + + The number sqrt(2pi) + + + The number sqrt(pi/2) + + + The number sqrt(2*pi*e) + + + The number log(sqrt(2*pi)) + + + The number log(sqrt(2*pi*e)) + + + The number log(2 * sqrt(e / pi)) + + + The number 1/pi + + + The number 2/pi + + + The number 1/sqrt(pi) + + + The number 1/sqrt(2pi) + + + The number 2/sqrt(pi) + + + The number 2 * sqrt(e / pi) + + + The number (pi)/180 - factor to convert from Degree (deg) to Radians (rad). + + + + + The number (pi)/200 - factor to convert from NewGrad (grad) to Radians (rad). + + + + + The number ln(10)/20 - factor to convert from Power Decibel (dB) to Neper (Np). Use this version when the Decibel represent a power gain but the compared values are not powers (e.g. amplitude, current, voltage). + + + The number ln(10)/10 - factor to convert from Neutral Decibel (dB) to Neper (Np). Use this version when either both or neither of the Decibel and the compared values represent powers. + + + The Catalan constant + Sum(k=0 -> inf){ (-1)^k/(2*k + 1)2 } + + + The Euler-Mascheroni constant + lim(n -> inf){ Sum(k=1 -> n) { 1/k - log(n) } } + + + The number (1+sqrt(5))/2, also known as the golden ratio + + + The Glaisher constant + e^(1/12 - Zeta(-1)) + + + The Khinchin constant + prod(k=1 -> inf){1+1/(k*(k+2))^log(k,2)} + + + + The size of a double in bytes. + + + + + The size of an int in bytes. + + + + + The size of a float in bytes. + + + + + The size of a Complex in bytes. + + + + + The size of a Complex in bytes. + + + + Speed of Light in Vacuum: c_0 = 2.99792458e8 [m s^-1] (defined, exact; 2007 CODATA) + + + Magnetic Permeability in Vacuum: mu_0 = 4*Pi * 10^-7 [N A^-2 = kg m A^-2 s^-2] (defined, exact; 2007 CODATA) + + + Electric Permittivity in Vacuum: epsilon_0 = 1/(mu_0*c_0^2) [F m^-1 = A^2 s^4 kg^-1 m^-3] (defined, exact; 2007 CODATA) + + + Characteristic Impedance of Vacuum: Z_0 = mu_0*c_0 [Ohm = m^2 kg s^-3 A^-2] (defined, exact; 2007 CODATA) + + + Newtonian Constant of Gravitation: G = 6.67429e-11 [m^3 kg^-1 s^-2] (2007 CODATA) + + + Planck's constant: h = 6.62606896e-34 [J s = m^2 kg s^-1] (2007 CODATA) + + + Reduced Planck's constant: h_bar = h / (2*Pi) [J s = m^2 kg s^-1] (2007 CODATA) + + + Planck mass: m_p = (h_bar*c_0/G)^(1/2) [kg] (2007 CODATA) + + + Planck temperature: T_p = (h_bar*c_0^5/G)^(1/2)/k [K] (2007 CODATA) + + + Planck length: l_p = h_bar/(m_p*c_0) [m] (2007 CODATA) + + + Planck time: t_p = l_p/c_0 [s] (2007 CODATA) + + + Elementary Electron Charge: e = 1.602176487e-19 [C = A s] (2007 CODATA) + + + Magnetic Flux Quantum: theta_0 = h/(2*e) [Wb = m^2 kg s^-2 A^-1] (2007 CODATA) + + + Conductance Quantum: G_0 = 2*e^2/h [S = m^-2 kg^-1 s^3 A^2] (2007 CODATA) + + + Josephson Constant: K_J = 2*e/h [Hz V^-1] (2007 CODATA) + + + Von Klitzing Constant: R_K = h/e^2 [Ohm = m^2 kg s^-3 A^-2] (2007 CODATA) + + + Bohr Magneton: mu_B = e*h_bar/2*m_e [J T^-1] (2007 CODATA) + + + Nuclear Magneton: mu_N = e*h_bar/2*m_p [J T^-1] (2007 CODATA) + + + Fine Structure Constant: alpha = e^2/4*Pi*e_0*h_bar*c_0 [1] (2007 CODATA) + + + Rydberg Constant: R_infty = alpha^2*m_e*c_0/2*h [m^-1] (2007 CODATA) + + + Bor Radius: a_0 = alpha/4*Pi*R_infty [m] (2007 CODATA) + + + Hartree Energy: E_h = 2*R_infty*h*c_0 [J] (2007 CODATA) + + + Quantum of Circulation: h/2*m_e [m^2 s^-1] (2007 CODATA) + + + Fermi Coupling Constant: G_F/(h_bar*c_0)^3 [GeV^-2] (2007 CODATA) + + + Weak Mixin Angle: sin^2(theta_W) [1] (2007 CODATA) + + + Electron Mass: [kg] (2007 CODATA) + + + Electron Mass Energy Equivalent: [J] (2007 CODATA) + + + Electron Molar Mass: [kg mol^-1] (2007 CODATA) + + + Electron Compton Wavelength: [m] (2007 CODATA) + + + Classical Electron Radius: [m] (2007 CODATA) + + + Thomson Cross Section: [m^2] (2002 CODATA) + + + Electron Magnetic Moment: [J T^-1] (2007 CODATA) + + + Electon G-Factor: [1] (2007 CODATA) + + + Muon Mass: [kg] (2007 CODATA) + + + Muon Mass Energy Equivalent: [J] (2007 CODATA) + + + Muon Molar Mass: [kg mol^-1] (2007 CODATA) + + + Muon Compton Wavelength: [m] (2007 CODATA) + + + Muon Magnetic Moment: [J T^-1] (2007 CODATA) + + + Muon G-Factor: [1] (2007 CODATA) + + + Tau Mass: [kg] (2007 CODATA) + + + Tau Mass Energy Equivalent: [J] (2007 CODATA) + + + Tau Molar Mass: [kg mol^-1] (2007 CODATA) + + + Tau Compton Wavelength: [m] (2007 CODATA) + + + Proton Mass: [kg] (2007 CODATA) + + + Proton Mass Energy Equivalent: [J] (2007 CODATA) + + + Proton Molar Mass: [kg mol^-1] (2007 CODATA) + + + Proton Compton Wavelength: [m] (2007 CODATA) + + + Proton Magnetic Moment: [J T^-1] (2007 CODATA) + + + Proton G-Factor: [1] (2007 CODATA) + + + Proton Shielded Magnetic Moment: [J T^-1] (2007 CODATA) + + + Proton Gyro-Magnetic Ratio: [s^-1 T^-1] (2007 CODATA) + + + Proton Shielded Gyro-Magnetic Ratio: [s^-1 T^-1] (2007 CODATA) + + + Neutron Mass: [kg] (2007 CODATA) + + + Neutron Mass Energy Equivalent: [J] (2007 CODATA) + + + Neutron Molar Mass: [kg mol^-1] (2007 CODATA) + + + Neuron Compton Wavelength: [m] (2007 CODATA) + + + Neutron Magnetic Moment: [J T^-1] (2007 CODATA) + + + Neutron G-Factor: [1] (2007 CODATA) + + + Neutron Gyro-Magnetic Ratio: [s^-1 T^-1] (2007 CODATA) + + + Deuteron Mass: [kg] (2007 CODATA) + + + Deuteron Mass Energy Equivalent: [J] (2007 CODATA) + + + Deuteron Molar Mass: [kg mol^-1] (2007 CODATA) + + + Deuteron Magnetic Moment: [J T^-1] (2007 CODATA) + + + Helion Mass: [kg] (2007 CODATA) + + + Helion Mass Energy Equivalent: [J] (2007 CODATA) + + + Helion Molar Mass: [kg mol^-1] (2007 CODATA) + + + Avogadro constant: [mol^-1] (2010 CODATA) + + + The SI prefix factor corresponding to 1 000 000 000 000 000 000 000 000 + + + The SI prefix factor corresponding to 1 000 000 000 000 000 000 000 + + + The SI prefix factor corresponding to 1 000 000 000 000 000 000 + + + The SI prefix factor corresponding to 1 000 000 000 000 000 + + + The SI prefix factor corresponding to 1 000 000 000 000 + + + The SI prefix factor corresponding to 1 000 000 000 + + + The SI prefix factor corresponding to 1 000 000 + + + The SI prefix factor corresponding to 1 000 + + + The SI prefix factor corresponding to 100 + + + The SI prefix factor corresponding to 10 + + + The SI prefix factor corresponding to 0.1 + + + The SI prefix factor corresponding to 0.01 + + + The SI prefix factor corresponding to 0.001 + + + The SI prefix factor corresponding to 0.000 001 + + + The SI prefix factor corresponding to 0.000 000 001 + + + The SI prefix factor corresponding to 0.000 000 000 001 + + + The SI prefix factor corresponding to 0.000 000 000 000 001 + + + The SI prefix factor corresponding to 0.000 000 000 000 000 001 + + + The SI prefix factor corresponding to 0.000 000 000 000 000 000 001 + + + The SI prefix factor corresponding to 0.000 000 000 000 000 000 000 001 + + + + Sets parameters for the library. + + + + + Use a specific provider if configured, e.g. using + environment variables, or fall back to the best providers. + + + + + Use the best provider available. + + + + + Use the Intel MKL native provider for linear algebra. + Throws if it is not available or failed to initialize, in which case the previous provider is still active. + + + + + Try to use the Intel MKL native provider for linear algebra. + + + True if the provider was found and initialized successfully. + False if it failed and the previous provider is still active. + + + + + Use the Nvidia CUDA native provider for linear algebra. + Throws if it is not available or failed to initialize, in which case the previous provider is still active. + + + + + Try to use the Nvidia CUDA native provider for linear algebra. + + + True if the provider was found and initialized successfully. + False if it failed and the previous provider is still active. + + + + + Use the OpenBLAS native provider for linear algebra. + Throws if it is not available or failed to initialize, in which case the previous provider is still active. + + + + + Try to use the OpenBLAS native provider for linear algebra. + + + True if the provider was found and initialized successfully. + False if it failed and the previous provider is still active. + + + + + Try to use any available native provider in an undefined order. + + + True if one of the native providers was found and successfully initialized. + False if it failed and the previous provider is still active. + + + + + Gets or sets a value indicating whether the distribution classes check validate each parameter. + For the multivariate distributions this could involve an expensive matrix factorization. + The default setting of this property is true. + + + + + Gets or sets a value indicating whether to use thread safe random number generators (RNG). + Thread safe RNG about two and half time slower than non-thread safe RNG. + + + true to use thread safe random number generators ; otherwise, false. + + + + + Optional path to try to load native provider binaries from. + + + + + Gets or sets a value indicating how many parallel worker threads shall be used + when parallelization is applicable. + + Default to the number of processor cores, must be between 1 and 1024 (inclusive). + + + + Gets or sets the TaskScheduler used to schedule the worker tasks. + + + + + Gets or sets the order of the matrix when linear algebra provider + must calculate multiply in parallel threads. + + The order. Default 64, must be at least 3. + + + + Gets or sets the number of elements a vector or matrix + must contain before we multiply threads. + + Number of elements. Default 300, must be at least 3. + + + + Numerical Derivative. + + + + + Initialized a NumericalDerivative with the given points and center. + + + + + Initialized a NumericalDerivative with the default points and center for the given order. + + + + + Evaluates the derivative of a scalar univariate function. + + Univariate function handle. + Point at which to evaluate the derivative. + Derivative order. + + + + Creates a function handle for the derivative of a scalar univariate function. + + Univariate function handle. + Derivative order. + + + + Evaluates the first derivative of a scalar univariate function. + + Univariate function handle. + Point at which to evaluate the derivative. + + + + Creates a function handle for the first derivative of a scalar univariate function. + + Univariate function handle. + + + + Evaluates the second derivative of a scalar univariate function. + + Univariate function handle. + Point at which to evaluate the derivative. + + + + Creates a function handle for the second derivative of a scalar univariate function. + + Univariate function handle. + + + + Evaluates the partial derivative of a multivariate function. + + Multivariate function handle. + Vector at which to evaluate the derivative. + Index of independent variable for partial derivative. + Derivative order. + + + + Creates a function handle for the partial derivative of a multivariate function. + + Multivariate function handle. + Index of independent variable for partial derivative. + Derivative order. + + + + Evaluates the first partial derivative of a multivariate function. + + Multivariate function handle. + Vector at which to evaluate the derivative. + Index of independent variable for partial derivative. + + + + Creates a function handle for the first partial derivative of a multivariate function. + + Multivariate function handle. + Index of independent variable for partial derivative. + + + + Evaluates the partial derivative of a bivariate function. + + Bivariate function handle. + First argument at which to evaluate the derivative. + Second argument at which to evaluate the derivative. + Index of independent variable for partial derivative. + Derivative order. + + + + Creates a function handle for the partial derivative of a bivariate function. + + Bivariate function handle. + Index of independent variable for partial derivative. + Derivative order. + + + + Evaluates the first partial derivative of a bivariate function. + + Bivariate function handle. + First argument at which to evaluate the derivative. + Second argument at which to evaluate the derivative. + Index of independent variable for partial derivative. + + + + Creates a function handle for the first partial derivative of a bivariate function. + + Bivariate function handle. + Index of independent variable for partial derivative. + + + + Class to calculate finite difference coefficients using Taylor series expansion method. + + + For n points, coefficients are calculated up to the maximum derivative order possible (n-1). + The current function value position specifies the "center" for surrounding coefficients. + Selecting the first, middle or last positions represent forward, backwards and central difference methods. + + + + + + + Number of points for finite difference coefficients. Changing this value recalculates the coefficients table. + + + + + Initializes a new instance of the class. + + Number of finite difference coefficients. + + + + Gets the finite difference coefficients for a specified center and order. + + Current function position with respect to coefficients. Must be within point range. + Order of finite difference coefficients. + Vector of finite difference coefficients. + + + + Gets the finite difference coefficients for all orders at a specified center. + + Current function position with respect to coefficients. Must be within point range. + Rectangular array of coefficients, with columns specifying order. + + + + Type of finite different step size. + + + + + The absolute step size value will be used in numerical derivatives, regardless of order or function parameters. + + + + + A base step size value, h, will be scaled according to the function input parameter. A common example is hx = h*(1+abs(x)), however + this may vary depending on implementation. This definition only guarantees that the only scaling will be relative to the + function input parameter and not the order of the finite difference derivative. + + + + + A base step size value, eps (typically machine precision), is scaled according to the finite difference coefficient order + and function input parameter. The initial scaling according to finite different coefficient order can be thought of as producing a + base step size, h, that is equivalent to scaling. This step size is then scaled according to the function + input parameter. Although implementation may vary, an example of second order accurate scaling may be (eps)^(1/3)*(1+abs(x)). + + + + + Class to evaluate the numerical derivative of a function using finite difference approximations. + Variable point and center methods can be initialized . + This class can also be used to return function handles (delegates) for a fixed derivative order and variable. + It is possible to evaluate the derivative and partial derivative of univariate and multivariate functions respectively. + + + + + Initializes a NumericalDerivative class with the default 3 point center difference method. + + + + + Initialized a NumericalDerivative class. + + Number of points for finite difference derivatives. + Location of the center with respect to other points. Value ranges from zero to points-1. + + + + Sets and gets the finite difference step size. This value is for each function evaluation if relative step size types are used. + If the base step size used in scaling is desired, see . + + + Setting then getting the StepSize may return a different value. This is not unusual since a user-defined step size is converted to a + base-2 representable number to improve finite difference accuracy. + + + + + Sets and gets the base finite difference step size. This assigned value to this parameter is only used if is set to RelativeX. + However, if the StepType is Relative, it will contain the base step size computed from based on the finite difference order. + + + + + Sets and gets the base finite difference step size. This parameter is only used if is set to Relative. + By default this is set to machine epsilon, from which is computed. + + + + + Sets and gets the location of the center point for the finite difference derivative. + + + + + Number of times a function is evaluated for numerical derivatives. + + + + + Type of step size for computing finite differences. If set to absolute, dx = h. + If set to relative, dx = (1+abs(x))*h^(2/(order+1)). This provides accurate results when + h is approximately equal to the square-root of machine accuracy, epsilon. + + + + + Evaluates the derivative of equidistant points using the finite difference method. + + Vector of points StepSize apart. + Derivative order. + Finite difference step size. + Derivative of points of the specified order. + + + + Evaluates the derivative of a scalar univariate function. + + + Supplying the optional argument currentValue will reduce the number of function evaluations + required to calculate the finite difference derivative. + + Function handle. + Point at which to compute the derivative. + Derivative order. + Current function value at center. + Function derivative at x of the specified order. + + + + Creates a function handle for the derivative of a scalar univariate function. + + Input function handle. + Derivative order. + Function handle that evaluates the derivative of input function at a fixed order. + + + + Evaluates the partial derivative of a multivariate function. + + Multivariate function handle. + Vector at which to evaluate the derivative. + Index of independent variable for partial derivative. + Derivative order. + Current function value at center. + Function partial derivative at x of the specified order. + + + + Evaluates the partial derivatives of a multivariate function array. + + + This function assumes the input vector x is of the correct length for f. + + Multivariate vector function array handle. + Vector at which to evaluate the derivatives. + Index of independent variable for partial derivative. + Derivative order. + Current function value at center. + Vector of functions partial derivatives at x of the specified order. + + + + Creates a function handle for the partial derivative of a multivariate function. + + Input function handle. + Index of the independent variable for partial derivative. + Derivative order. + Function handle that evaluates partial derivative of input function at a fixed order. + + + + Creates a function handle for the partial derivative of a vector multivariate function. + + Input function handle. + Index of the independent variable for partial derivative. + Derivative order. + Function handle that evaluates partial derivative of input function at fixed order. + + + + Evaluates the mixed partial derivative of variable order for multivariate functions. + + + This function recursively uses to evaluate mixed partial derivative. + Therefore, it is more efficient to call for higher order derivatives of + a single independent variable. + + Multivariate function handle. + Points at which to evaluate the derivative. + Vector of indices for the independent variables at descending derivative orders. + Highest order of differentiation. + Current function value at center. + Function mixed partial derivative at x of the specified order. + + + + Evaluates the mixed partial derivative of variable order for multivariate function arrays. + + + This function recursively uses to evaluate mixed partial derivative. + Therefore, it is more efficient to call for higher order derivatives of + a single independent variable. + + Multivariate function array handle. + Vector at which to evaluate the derivative. + Vector of indices for the independent variables at descending derivative orders. + Highest order of differentiation. + Current function value at center. + Function mixed partial derivatives at x of the specified order. + + + + Creates a function handle for the mixed partial derivative of a multivariate function. + + Input function handle. + Vector of indices for the independent variables at descending derivative orders. + Highest derivative order. + Function handle that evaluates the fixed mixed partial derivative of input function at fixed order. + + + + Creates a function handle for the mixed partial derivative of a multivariate vector function. + + Input vector function handle. + Vector of indices for the independent variables at descending derivative orders. + Highest derivative order. + Function handle that evaluates the fixed mixed partial derivative of input function at fixed order. + + + + Resets the evaluation counter. + + + + + Class for evaluating the Hessian of a smooth continuously differentiable function using finite differences. + By default, a central 3-point method is used. + + + + + Number of function evaluations. + + + + + Creates a numerical Hessian object with a three point central difference method. + + + + + Creates a numerical Hessian with a specified differentiation scheme. + + Number of points for Hessian evaluation. + Center point for differentiation. + + + + Evaluates the Hessian of the scalar univariate function f at points x. + + Scalar univariate function handle. + Point at which to evaluate Hessian. + Hessian tensor. + + + + Evaluates the Hessian of a multivariate function f at points x. + + + This method of computing the Hessian is only valid for Lipschitz continuous functions. + The function mirrors the Hessian along the diagonal since d2f/dxdy = d2f/dydx for continuously differentiable functions. + + Multivariate function handle.> + Points at which to evaluate Hessian.> + Hessian tensor. + + + + Resets the function evaluation counter for the Hessian. + + + + + Class for evaluating the Jacobian of a function using finite differences. + By default, a central 3-point method is used. + + + + + Number of function evaluations. + + + + + Creates a numerical Jacobian object with a three point central difference method. + + + + + Creates a numerical Jacobian with a specified differentiation scheme. + + Number of points for Jacobian evaluation. + Center point for differentiation. + + + + Evaluates the Jacobian of scalar univariate function f at point x. + + Scalar univariate function handle. + Point at which to evaluate Jacobian. + Jacobian vector. + + + + Evaluates the Jacobian of a multivariate function f at vector x. + + + This function assumes that the length of vector x consistent with the argument count of f. + + Multivariate function handle. + Points at which to evaluate Jacobian. + Jacobian vector. + + + + Evaluates the Jacobian of a multivariate function f at vector x given a current function value. + + + To minimize the number of function evaluations, a user can supply the current value of the function + to be used in computing the Jacobian. This value must correspond to the "center" location for the + finite differencing. If a scheme is used where the center value is not evaluated, this will provide no + added efficiency. This method also assumes that the length of vector x consistent with the argument count of f. + + Multivariate function handle. + Points at which to evaluate Jacobian. + Current function value at finite difference center. + Jacobian vector. + + + + Evaluates the Jacobian of a multivariate function array f at vector x. + + Multivariate function array handle. + Vector at which to evaluate Jacobian. + Jacobian matrix. + + + + Evaluates the Jacobian of a multivariate function array f at vector x given a vector of current function values. + + + To minimize the number of function evaluations, a user can supply a vector of current values of the functions + to be used in computing the Jacobian. These value must correspond to the "center" location for the + finite differencing. If a scheme is used where the center value is not evaluated, this will provide no + added efficiency. This method also assumes that the length of vector x consistent with the argument count of f. + + Multivariate function array handle. + Vector at which to evaluate Jacobian. + Vector of current function values. + Jacobian matrix. + + + + Resets the function evaluation counter for the Jacobian. + + + + + Evaluates the Riemann-Liouville fractional derivative that uses the double exponential integration. + + + order = 1.0 : normal derivative + order = 0.5 : semi-derivative + order = -0.5 : semi-integral + order = -1.0 : normal integral + + The analytic smooth function to differintegrate. + The evaluation point. + The order of fractional derivative. + The reference point of integration. + The expected relative accuracy of the Double-Exponential integration. + Approximation of the differintegral of order n at x. + + + + Evaluates the Riemann-Liouville fractional derivative that uses the Gauss-Legendre integration. + + + order = 1.0 : normal derivative + order = 0.5 : semi-derivative + order = -0.5 : semi-integral + order = -1.0 : normal integral + + The analytic smooth function to differintegrate. + The evaluation point. + The order of fractional derivative. + The reference point of integration. + The number of Gauss-Legendre points. + Approximation of the differintegral of order n at x. + + + + Evaluates the Riemann-Liouville fractional derivative that uses the Gauss-Kronrod integration. + + + order = 1.0 : normal derivative + order = 0.5 : semi-derivative + order = -0.5 : semi-integral + order = -1.0 : normal integral + + The analytic smooth function to differintegrate. + The evaluation point. + The order of fractional derivative. + The reference point of integration. + The expected relative accuracy of the Gauss-Kronrod integration. + The number of Gauss-Kronrod points. Pre-computed for 15, 21, 31, 41, 51 and 61 points. + Approximation of the differintegral of order n at x. + + + + Metrics to measure the distance between two structures. + + + + + Sum of Absolute Difference (SAD), i.e. the L1-norm (Manhattan) of the difference. + + + + + Sum of Absolute Difference (SAD), i.e. the L1-norm (Manhattan) of the difference. + + + + + Sum of Absolute Difference (SAD), i.e. the L1-norm (Manhattan) of the difference. + + + + + Mean-Absolute Error (MAE), i.e. the normalized L1-norm (Manhattan) of the difference. + + + + + Mean-Absolute Error (MAE), i.e. the normalized L1-norm (Manhattan) of the difference. + + + + + Mean-Absolute Error (MAE), i.e. the normalized L1-norm (Manhattan) of the difference. + + + + + Sum of Squared Difference (SSD), i.e. the squared L2-norm (Euclidean) of the difference. + + + + + Sum of Squared Difference (SSD), i.e. the squared L2-norm (Euclidean) of the difference. + + + + + Sum of Squared Difference (SSD), i.e. the squared L2-norm (Euclidean) of the difference. + + + + + Mean-Squared Error (MSE), i.e. the normalized squared L2-norm (Euclidean) of the difference. + + + + + Mean-Squared Error (MSE), i.e. the normalized squared L2-norm (Euclidean) of the difference. + + + + + Mean-Squared Error (MSE), i.e. the normalized squared L2-norm (Euclidean) of the difference. + + + + + Euclidean Distance, i.e. the L2-norm of the difference. + + + + + Euclidean Distance, i.e. the L2-norm of the difference. + + + + + Euclidean Distance, i.e. the L2-norm of the difference. + + + + + Manhattan Distance, i.e. the L1-norm of the difference. + + + + + Manhattan Distance, i.e. the L1-norm of the difference. + + + + + Manhattan Distance, i.e. the L1-norm of the difference. + + + + + Chebyshev Distance, i.e. the Infinity-norm of the difference. + + + + + Chebyshev Distance, i.e. the Infinity-norm of the difference. + + + + + Chebyshev Distance, i.e. the Infinity-norm of the difference. + + + + + Minkowski Distance, i.e. the generalized p-norm of the difference. + + + + + Minkowski Distance, i.e. the generalized p-norm of the difference. + + + + + Minkowski Distance, i.e. the generalized p-norm of the difference. + + + + + Canberra Distance, a weighted version of the L1-norm of the difference. + + + + + Canberra Distance, a weighted version of the L1-norm of the difference. + + + + + Cosine Distance, representing the angular distance while ignoring the scale. + + + + + Cosine Distance, representing the angular distance while ignoring the scale. + + + + + Hamming Distance, i.e. the number of positions that have different values in the vectors. + + + + + Hamming Distance, i.e. the number of positions that have different values in the vectors. + + + + + Pearson's distance, i.e. 1 - the person correlation coefficient. + + + + + Jaccard distance, i.e. 1 - the Jaccard index. + + Thrown if a or b are null. + Throw if a and b are of different lengths. + Jaccard distance. + + + + Jaccard distance, i.e. 1 - the Jaccard index. + + Thrown if a or b are null. + Throw if a and b are of different lengths. + Jaccard distance. + + + + Discrete Univariate Bernoulli distribution. + The Bernoulli distribution is a distribution over bits. The parameter + p specifies the probability that a 1 is generated. + Wikipedia - Bernoulli distribution. + + + + + Initializes a new instance of the Bernoulli class. + + The probability (p) of generating one. Range: 0 ≤ p ≤ 1. + If the Bernoulli parameter is not in the range [0,1]. + + + + Initializes a new instance of the Bernoulli class. + + The probability (p) of generating one. Range: 0 ≤ p ≤ 1. + The random number generator which is used to draw random samples. + If the Bernoulli parameter is not in the range [0,1]. + + + + A string representation of the distribution. + + a string representation of the distribution. + + + + Tests whether the provided values are valid parameters for this distribution. + + The probability (p) of generating one. Range: 0 ≤ p ≤ 1. + + + + Gets the probability of generating a one. Range: 0 ≤ p ≤ 1. + + + + + Gets or sets the random number generator which is used to draw random samples. + + + + + Gets the mean of the distribution. + + + + + Gets the standard deviation of the distribution. + + + + + Gets the variance of the distribution. + + + + + Gets the entropy of the distribution. + + + + + Gets the skewness of the distribution. + + + + + Gets the smallest element in the domain of the distributions which can be represented by an integer. + + + + + Gets the largest element in the domain of the distributions which can be represented by an integer. + + + + + Gets the mode of the distribution. + + + + + Gets all modes of the distribution. + + + + + Gets the median of the distribution. + + + + + Computes the probability mass (PMF) at k, i.e. P(X = k). + + The location in the domain where we want to evaluate the probability mass function. + the probability mass at location . + + + + Computes the log probability mass (lnPMF) at k, i.e. ln(P(X = k)). + + The location in the domain where we want to evaluate the log probability mass function. + the log probability mass at location . + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + the cumulative distribution at location . + + + + Computes the probability mass (PMF) at k, i.e. P(X = k). + + The location in the domain where we want to evaluate the probability mass function. + The probability (p) of generating one. Range: 0 ≤ p ≤ 1. + the probability mass at location . + + + + Computes the log probability mass (lnPMF) at k, i.e. ln(P(X = k)). + + The location in the domain where we want to evaluate the log probability mass function. + The probability (p) of generating one. Range: 0 ≤ p ≤ 1. + the log probability mass at location . + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + The probability (p) of generating one. Range: 0 ≤ p ≤ 1. + the cumulative distribution at location . + + + + + Generates one sample from the Bernoulli distribution. + + The random source to use. + The probability (p) of generating one. Range: 0 ≤ p ≤ 1. + A random sample from the Bernoulli distribution. + + + + Samples a Bernoulli distributed random variable. + + A sample from the Bernoulli distribution. + + + + Fills an array with samples generated from the distribution. + + + + + Samples an array of Bernoulli distributed random variables. + + a sequence of samples from the distribution. + + + + Samples a Bernoulli distributed random variable. + + The random number generator to use. + The probability (p) of generating one. Range: 0 ≤ p ≤ 1. + A sample from the Bernoulli distribution. + + + + Samples a sequence of Bernoulli distributed random variables. + + The random number generator to use. + The probability (p) of generating one. Range: 0 ≤ p ≤ 1. + a sequence of samples from the distribution. + + + + Fills an array with samples generated from the distribution. + + The random number generator to use. + The array to fill with the samples. + The probability (p) of generating one. Range: 0 ≤ p ≤ 1. + a sequence of samples from the distribution. + + + + Samples a Bernoulli distributed random variable. + + The probability (p) of generating one. Range: 0 ≤ p ≤ 1. + A sample from the Bernoulli distribution. + + + + Samples a sequence of Bernoulli distributed random variables. + + The probability (p) of generating one. Range: 0 ≤ p ≤ 1. + a sequence of samples from the distribution. + + + + Fills an array with samples generated from the distribution. + + The array to fill with the samples. + The probability (p) of generating one. Range: 0 ≤ p ≤ 1. + a sequence of samples from the distribution. + + + + Continuous Univariate Beta distribution. + For details about this distribution, see + Wikipedia - Beta distribution. + + + There are a few special cases for the parameterization of the Beta distribution. When both + shape parameters are positive infinity, the Beta distribution degenerates to a point distribution + at 0.5. When one of the shape parameters is positive infinity, the distribution degenerates to a point + distribution at the positive infinity. When both shape parameters are 0.0, the Beta distribution + degenerates to a Bernoulli distribution with parameter 0.5. When one shape parameter is 0.0, the + distribution degenerates to a point distribution at the non-zero shape parameter. + + + + + Initializes a new instance of the Beta class. + + The α shape parameter of the Beta distribution. Range: α ≥ 0. + The β shape parameter of the Beta distribution. Range: β ≥ 0. + + + + Initializes a new instance of the Beta class. + + The α shape parameter of the Beta distribution. Range: α ≥ 0. + The β shape parameter of the Beta distribution. Range: β ≥ 0. + The random number generator which is used to draw random samples. + + + + A string representation of the distribution. + + A string representation of the Beta distribution. + + + + Tests whether the provided values are valid parameters for this distribution. + + The α shape parameter of the Beta distribution. Range: α ≥ 0. + The β shape parameter of the Beta distribution. Range: β ≥ 0. + + + + Gets the α shape parameter of the Beta distribution. Range: α ≥ 0. + + + + + Gets the β shape parameter of the Beta distribution. Range: β ≥ 0. + + + + + Gets or sets the random number generator which is used to draw random samples. + + + + + Gets the mean of the Beta distribution. + + + + + Gets the variance of the Beta distribution. + + + + + Gets the standard deviation of the Beta distribution. + + + + + Gets the entropy of the Beta distribution. + + + + + Gets the skewness of the Beta distribution. + + + + + Gets the mode of the Beta distribution; when there are multiple answers, this routine will return 0.5. + + + + + Gets the median of the Beta distribution. + + + + + Gets the minimum of the Beta distribution. + + + + + Gets the maximum of the Beta distribution. + + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The location at which to compute the density. + the density at . + + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The location at which to compute the log density. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + the cumulative distribution at location . + + + + + Computes the inverse of the cumulative distribution function (InvCDF) for the distribution + at the given probability. This is also known as the quantile or percent point function. + + The location at which to compute the inverse cumulative density. + the inverse cumulative density at . + + WARNING: currently not an explicit implementation, hence slow and unreliable. + + + + Generates a sample from the Beta distribution. + + a sample from the distribution. + + + + Fills an array with samples generated from the distribution. + + + + + Generates a sequence of samples from the Beta distribution. + + a sequence of samples from the distribution. + + + + Samples Beta distributed random variables by sampling two Gamma variables and normalizing. + + The random number generator to use. + The α shape parameter of the Beta distribution. Range: α ≥ 0. + The β shape parameter of the Beta distribution. Range: β ≥ 0. + a random number from the Beta distribution. + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The α shape parameter of the Beta distribution. Range: α ≥ 0. + The β shape parameter of the Beta distribution. Range: β ≥ 0. + The location at which to compute the density. + the density at . + + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The α shape parameter of the Beta distribution. Range: α ≥ 0. + The β shape parameter of the Beta distribution. Range: β ≥ 0. + The location at which to compute the density. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + The α shape parameter of the Beta distribution. Range: α ≥ 0. + The β shape parameter of the Beta distribution. Range: β ≥ 0. + the cumulative distribution at location . + + + + + Computes the inverse of the cumulative distribution function (InvCDF) for the distribution + at the given probability. This is also known as the quantile or percent point function. + + The location at which to compute the inverse cumulative density. + The α shape parameter of the Beta distribution. Range: α ≥ 0. + The β shape parameter of the Beta distribution. Range: β ≥ 0. + the inverse cumulative density at . + + WARNING: currently not an explicit implementation, hence slow and unreliable. + + + + Generates a sample from the distribution. + + The random number generator to use. + The α shape parameter of the Beta distribution. Range: α ≥ 0. + The β shape parameter of the Beta distribution. Range: β ≥ 0. + a sample from the distribution. + + + + Generates a sequence of samples from the distribution. + + The random number generator to use. + The α shape parameter of the Beta distribution. Range: α ≥ 0. + The β shape parameter of the Beta distribution. Range: β ≥ 0. + a sequence of samples from the distribution. + + + + Fills an array with samples generated from the distribution. + + The random number generator to use. + The array to fill with the samples. + The α shape parameter of the Beta distribution. Range: α ≥ 0. + The β shape parameter of the Beta distribution. Range: β ≥ 0. + a sequence of samples from the distribution. + + + + Generates a sample from the distribution. + + The α shape parameter of the Beta distribution. Range: α ≥ 0. + The β shape parameter of the Beta distribution. Range: β ≥ 0. + a sample from the distribution. + + + + Generates a sequence of samples from the distribution. + + The α shape parameter of the Beta distribution. Range: α ≥ 0. + The β shape parameter of the Beta distribution. Range: β ≥ 0. + a sequence of samples from the distribution. + + + + Fills an array with samples generated from the distribution. + + The array to fill with the samples. + The α shape parameter of the Beta distribution. Range: α ≥ 0. + The β shape parameter of the Beta distribution. Range: β ≥ 0. + a sequence of samples from the distribution. + + + + Discrete Univariate Beta-Binomial distribution. + The beta-binomial distribution is a family of discrete probability distributions on a finite support of non-negative integers arising + when the probability of success in each of a fixed or known number of Bernoulli trials is either unknown or random. + The beta-binomial distribution is the binomial distribution in which the probability of success at each of n trials is not fixed but randomly drawn from a beta distribution. + It is frequently used in Bayesian statistics, empirical Bayes methods and classical statistics to capture overdispersion in binomial type distributed data. + Wikipedia - Beta-Binomial distribution. + + + + + Initializes a new instance of the class. + + The number of Bernoulli trials n - n is a positive integer + Shape parameter alpha of the Beta distribution. Range: a > 0. + Shape parameter beta of the Beta distribution. Range: b > 0. + + + + Initializes a new instance of the class. + + The number of Bernoulli trials n - n is a positive integer + Shape parameter alpha of the Beta distribution. Range: a > 0. + Shape parameter beta of the Beta distribution. Range: b > 0. + The random number generator which is used to draw random samples. + + + + Returns a that represents this instance. + + + A that represents this instance. + + + + + Tests whether the provided values are valid parameters for this distribution. + + The number of Bernoulli trials n - n is a positive integer + Shape parameter alpha of the Beta distribution. Range: a > 0. + Shape parameter beta of the Beta distribution. Range: b > 0. + + + + Tests whether the provided values are valid parameters for this distribution. + + The number of Bernoulli trials n - n is a positive integer + Shape parameter alpha of the Beta distribution. Range: a > 0. + Shape parameter beta of the Beta distribution. Range: b > 0. + The location in the domain where we want to evaluate the probability mass function. + + + + Gets the mean of the distribution. + + + + + Gets the variance of the distribution. + + + + + Gets the standard deviation of the distribution. + + + + + Gets the entropy of the distribution. + + + + + Gets the skewness of the distribution. + + + + + Gets the mode of the distribution + + + + + Gets the median of the distribution. + + + + + Gets the smallest element in the domain of the distributions which can be represented by an integer. + + + + + Gets the largest element in the domain of the distributions which can be represented by an integer. + + + + + Computes the probability mass (PMF) at k, i.e. P(X = k). + + The location in the domain where we want to evaluate the probability mass function. + the probability mass at location . + + + + Computes the log probability mass (lnPMF) at k, i.e. ln(P(X = k)). + + The location in the domain where we want to evaluate the log probability mass function. + the log probability mass at location . + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + the cumulative distribution at location + + + + Computes the probability mass (PMF) at k, i.e. P(X = k). + + The number of Bernoulli trials n - n is a positive integer + Shape parameter alpha of the Beta distribution. Range: a > 0. + Shape parameter beta of the Beta distribution. Range: b > 0. + The location in the domain where we want to evaluate the probability mass function. + the probability mass at location . + + + + Computes the log probability mass (lnPMF) at k, i.e. ln(P(X = k)). + + The number of Bernoulli trials n - n is a positive integer + Shape parameter alpha of the Beta distribution. Range: a > 0. + Shape parameter beta of the Beta distribution. Range: b > 0. + The location in the domain where we want to evaluate the probability mass function. + the log probability mass at location . + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The number of Bernoulli trials n - n is a positive integer + Shape parameter alpha of the Beta distribution. Range: a > 0. + Shape parameter beta of the Beta distribution. Range: b > 0. + The location at which to compute the cumulative distribution function. + the cumulative distribution at location . + + + + + Samples BetaBinomial distributed random variables by sampling a Beta distribution then passing to a Binomial distribution. + + The random number generator to use. + The α shape parameter of the Beta distribution. Range: α ≥ 0. + The β shape parameter of the Beta distribution. Range: β ≥ 0. + The number of trials (n). Range: n ≥ 0. + a random number from the BetaBinomial distribution. + + + + Samples a BetaBinomial distributed random variable. + + a sample from the distribution. + + + + Fills an array with samples generated from the distribution. + + + + + Samples an array of BetaBinomial distributed random variables. + + a sequence of samples from the distribution. + + + + Samples a BetaBinomial distributed random variable. + + The random number generator to use. + The α shape parameter of the Beta distribution. Range: α ≥ 0. + The β shape parameter of the Beta distribution. Range: β ≥ 0. + The number of trials (n). Range: n ≥ 0. + a sample from the distribution. + + + + Fills an array with samples generated from the distribution. + + The random number generator to use. + The array to fill with the samples. + The α shape parameter of the Beta distribution. Range: α ≥ 0. + The β shape parameter of the Beta distribution. Range: β ≥ 0. + The number of trials (n). Range: n ≥ 0. + + + + Samples an array of BetaBinomial distributed random variables. + + The α shape parameter of the Beta distribution. Range: α ≥ 0. + The β shape parameter of the Beta distribution. Range: β ≥ 0. + The number of trials (n). Range: n ≥ 0. + a sequence of samples from the distribution. + + + + Fills an array with samples generated from the distribution. + + The array to fill with the samples. + The α shape parameter of the Beta distribution. Range: α ≥ 0. + The β shape parameter of the Beta distribution. Range: β ≥ 0. + The number of trials (n). Range: n ≥ 0. + + + + Initializes a new instance of the BetaScaled class. + + The α shape parameter of the BetaScaled distribution. Range: α > 0. + The β shape parameter of the BetaScaled distribution. Range: β > 0. + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + + + + Initializes a new instance of the BetaScaled class. + + The α shape parameter of the BetaScaled distribution. Range: α > 0. + The β shape parameter of the BetaScaled distribution. Range: β > 0. + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + The random number generator which is used to draw random samples. + + + + Create a Beta PERT distribution, used in risk analysis and other domains where an expert forecast + is used to construct an underlying beta distribution. + + The minimum value. + The maximum value. + The most likely value (mode). + The random number generator which is used to draw random samples. + The Beta distribution derived from the PERT parameters. + + + + A string representation of the distribution. + + A string representation of the BetaScaled distribution. + + + + Tests whether the provided values are valid parameters for this distribution. + + The α shape parameter of the BetaScaled distribution. Range: α > 0. + The β shape parameter of the BetaScaled distribution. Range: β > 0. + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + + + + Gets the α shape parameter of the BetaScaled distribution. Range: α > 0. + + + + + Gets the β shape parameter of the BetaScaled distribution. Range: β > 0. + + + + + Gets the location (μ) of the BetaScaled distribution. + + + + + Gets the scale (σ) of the BetaScaled distribution. Range: σ > 0. + + + + + Gets or sets the random number generator which is used to draw random samples. + + + + + Gets the mean of the BetaScaled distribution. + + + + + Gets the variance of the BetaScaled distribution. + + + + + Gets the standard deviation of the BetaScaled distribution. + + + + + Gets the entropy of the BetaScaled distribution. + + + + + Gets the skewness of the BetaScaled distribution. + + + + + Gets the mode of the BetaScaled distribution; when there are multiple answers, this routine will return 0.5. + + + + + Gets the median of the BetaScaled distribution. + + + + + Gets the minimum of the BetaScaled distribution. + + + + + Gets the maximum of the BetaScaled distribution. + + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The location at which to compute the density. + the density at . + + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The location at which to compute the log density. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + the cumulative distribution at location . + + + + + Computes the inverse of the cumulative distribution function (InvCDF) for the distribution + at the given probability. This is also known as the quantile or percent point function. + + The location at which to compute the inverse cumulative density. + the inverse cumulative density at . + + WARNING: currently not an explicit implementation, hence slow and unreliable. + + + + Generates a sample from the distribution. + + a sample from the distribution. + + + + Fills an array with samples generated from the distribution. + + + + + Generates a sequence of samples from the distribution. + + a sequence of samples from the distribution. + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The α shape parameter of the BetaScaled distribution. Range: α > 0. + The β shape parameter of the BetaScaled distribution. Range: β > 0. + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + The location at which to compute the density. + the density at . + + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The α shape parameter of the BetaScaled distribution. Range: α > 0. + The β shape parameter of the BetaScaled distribution. Range: β > 0. + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + The location at which to compute the density. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The α shape parameter of the BetaScaled distribution. Range: α > 0. + The β shape parameter of the BetaScaled distribution. Range: β > 0. + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + The location at which to compute the cumulative distribution function. + the cumulative distribution at location . + + + + + Computes the inverse of the cumulative distribution function (InvCDF) for the distribution + at the given probability. This is also known as the quantile or percent point function. + + The α shape parameter of the BetaScaled distribution. Range: α > 0. + The β shape parameter of the BetaScaled distribution. Range: β > 0. + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + The location at which to compute the inverse cumulative density. + the inverse cumulative density at . + + WARNING: currently not an explicit implementation, hence slow and unreliable. + + + + Generates a sample from the distribution. + + The random number generator to use. + The α shape parameter of the BetaScaled distribution. Range: α > 0. + The β shape parameter of the BetaScaled distribution. Range: β > 0. + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + a sample from the distribution. + + + + Generates a sequence of samples from the distribution. + + The random number generator to use. + The α shape parameter of the BetaScaled distribution. Range: α > 0. + The β shape parameter of the BetaScaled distribution. Range: β > 0. + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + a sequence of samples from the distribution. + + + + Fills an array with samples generated from the distribution. + + The random number generator to use. + The array to fill with the samples. + The α shape parameter of the BetaScaled distribution. Range: α > 0. + The β shape parameter of the BetaScaled distribution. Range: β > 0. + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + a sequence of samples from the distribution. + + + + Generates a sample from the distribution. + + The α shape parameter of the BetaScaled distribution. Range: α > 0. + The β shape parameter of the BetaScaled distribution. Range: β > 0. + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + a sample from the distribution. + + + + Generates a sequence of samples from the distribution. + + The α shape parameter of the BetaScaled distribution. Range: α > 0. + The β shape parameter of the BetaScaled distribution. Range: β > 0. + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + a sequence of samples from the distribution. + + + + Fills an array with samples generated from the distribution. + + The array to fill with the samples. + The α shape parameter of the BetaScaled distribution. Range: α > 0. + The β shape parameter of the BetaScaled distribution. Range: β > 0. + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + a sequence of samples from the distribution. + + + + Discrete Univariate Binomial distribution. + For details about this distribution, see + Wikipedia - Binomial distribution. + + + The distribution is parameterized by a probability (between 0.0 and 1.0). + + + + + Initializes a new instance of the Binomial class. + + The success probability (p) in each trial. Range: 0 ≤ p ≤ 1. + The number of trials (n). Range: n ≥ 0. + If is not in the interval [0.0,1.0]. + If is negative. + + + + Initializes a new instance of the Binomial class. + + The success probability (p) in each trial. Range: 0 ≤ p ≤ 1. + The number of trials (n). Range: n ≥ 0. + The random number generator which is used to draw random samples. + If is not in the interval [0.0,1.0]. + If is negative. + + + + A string representation of the distribution. + + a string representation of the distribution. + + + + Tests whether the provided values are valid parameters for this distribution. + + The success probability (p) in each trial. Range: 0 ≤ p ≤ 1. + The number of trials (n). Range: n ≥ 0. + + + + Gets the success probability in each trial. Range: 0 ≤ p ≤ 1. + + + + + Gets the number of trials. Range: n ≥ 0. + + + + + Gets or sets the random number generator which is used to draw random samples. + + + + + Gets the mean of the distribution. + + + + + Gets the standard deviation of the distribution. + + + + + Gets the variance of the distribution. + + + + + Gets the entropy of the distribution. + + + + + Gets the skewness of the distribution. + + + + + Gets the smallest element in the domain of the distributions which can be represented by an integer. + + + + + Gets the largest element in the domain of the distributions which can be represented by an integer. + + + + + Gets the mode of the distribution. + + + + + Gets all modes of the distribution. + + + + + Gets the median of the distribution. + + + + + Computes the probability mass (PMF) at k, i.e. P(X = k). + + The location in the domain where we want to evaluate the probability mass function. + the probability mass at location . + + + + Computes the log probability mass (lnPMF) at k, i.e. ln(P(X = k)). + + The location in the domain where we want to evaluate the log probability mass function. + the log probability mass at location . + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + the cumulative distribution at location . + + + + Computes the probability mass (PMF) at k, i.e. P(X = k). + + The location in the domain where we want to evaluate the probability mass function. + The success probability (p) in each trial. Range: 0 ≤ p ≤ 1. + The number of trials (n). Range: n ≥ 0. + the probability mass at location . + + + + Computes the log probability mass (lnPMF) at k, i.e. ln(P(X = k)). + + The location in the domain where we want to evaluate the log probability mass function. + The success probability (p) in each trial. Range: 0 ≤ p ≤ 1. + The number of trials (n). Range: n ≥ 0. + the log probability mass at location . + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + The success probability (p) in each trial. Range: 0 ≤ p ≤ 1. + The number of trials (n). Range: n ≥ 0. + the cumulative distribution at location . + + + + + Generates a sample from the Binomial distribution without doing parameter checking. + + The random number generator to use. + The success probability (p) in each trial. Range: 0 ≤ p ≤ 1. + The number of trials (n). Range: n ≥ 0. + The number of successful trials. + + + + Samples a Binomially distributed random variable. + + The number of successes in N trials. + + + + Fills an array with samples generated from the distribution. + + + + + Samples an array of Binomially distributed random variables. + + a sequence of successes in N trials. + + + + Samples a binomially distributed random variable. + + The random number generator to use. + The success probability (p) in each trial. Range: 0 ≤ p ≤ 1. + The number of trials (n). Range: n ≥ 0. + The number of successes in trials. + + + + Samples a sequence of binomially distributed random variable. + + The random number generator to use. + The success probability (p) in each trial. Range: 0 ≤ p ≤ 1. + The number of trials (n). Range: n ≥ 0. + a sequence of successes in trials. + + + + Fills an array with samples generated from the distribution. + + The random number generator to use. + The array to fill with the samples. + The success probability (p) in each trial. Range: 0 ≤ p ≤ 1. + The number of trials (n). Range: n ≥ 0. + a sequence of successes in trials. + + + + Samples a binomially distributed random variable. + + The success probability (p) in each trial. Range: 0 ≤ p ≤ 1. + The number of trials (n). Range: n ≥ 0. + The number of successes in trials. + + + + Samples a sequence of binomially distributed random variable. + + The success probability (p) in each trial. Range: 0 ≤ p ≤ 1. + The number of trials (n). Range: n ≥ 0. + a sequence of successes in trials. + + + + Fills an array with samples generated from the distribution. + + The array to fill with the samples. + The success probability (p) in each trial. Range: 0 ≤ p ≤ 1. + The number of trials (n). Range: n ≥ 0. + a sequence of successes in trials. + + + + Gets the scale (a) of the distribution. Range: a > 0. + + + + + Gets the first shape parameter (c) of the distribution. Range: c > 0. + + + + + Gets the second shape parameter (k) of the distribution. Range: k > 0. + + + + + Initializes a new instance of the Burr Type XII class. + + The scale parameter a of the Burr distribution. Range: a > 0. + The first shape parameter c of the Burr distribution. Range: c > 0. + The second shape parameter k of the Burr distribution. Range: k > 0. + The random number generator which is used to draw random samples. Optional, can be null. + + + + A string representation of the distribution. + + a string representation of the distribution. + + + + Tests whether the provided values are valid parameters for this distribution. + + The scale parameter a of the Burr distribution. Range: a > 0. + The first shape parameter c of the Burr distribution. Range: c > 0. + The second shape parameter k of the Burr distribution. Range: k > 0. + + + + Gets the random number generator which is used to draw random samples. + + + + + Gets the mean of the Burr distribution. + + + + + Gets the variance of the Burr distribution. + + + + + Gets the standard deviation of the Burr distribution. + + + + + Gets the mode of the Burr distribution. + + + + + Gets the minimum of the Burr distribution. + + + + + Gets the maximum of the Burr distribution. + + + + + Gets the entropy of the Burr distribution (currently not supported). + + + + + Gets the skewness of the Burr distribution. + + + + + Gets the median of the Burr distribution. + + + + + Generates a sample from the Burr distribution. + + a sample from the distribution. + + + + Fills an array with samples generated from the distribution. + + The array to fill with the samples. + + + + Generates a sequence of samples from the Burr distribution. + + a sequence of samples from the distribution. + + + + Generates a sample from the Burr distribution. + + The random number generator to use. + The scale parameter a of the Burr distribution. Range: a > 0. + The first shape parameter c of the Burr distribution. Range: c > 0. + The second shape parameter k of the Burr distribution. Range: k > 0. + a sample from the distribution. + + + + Fills an array with samples generated from the distribution. + + The random number generator to use. + The array to fill with the samples. + The scale parameter a of the Burr distribution. Range: a > 0. + The first shape parameter c of the Burr distribution. Range: c > 0. + The second shape parameter k of the Burr distribution. Range: k > 0. + + + + Generates a sequence of samples from the Burr distribution. + + The random number generator to use. + The scale parameter a of the Burr distribution. Range: a > 0. + The first shape parameter c of the Burr distribution. Range: c > 0. + The second shape parameter k of the Burr distribution. Range: k > 0. + a sequence of samples from the distribution. + + + + Gets the n-th raw moment of the distribution. + + The order (n) of the moment. Range: n ≥ 1. + the n-th moment of the distribution. + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The location at which to compute the density. + the density at . + + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The location at which to compute the log density. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + the cumulative distribution at location . + + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The scale parameter a of the Burr distribution. Range: a > 0. + The first shape parameter c of the Burr distribution. Range: c > 0. + The second shape parameter k of the Burr distribution. Range: k > 0. + The location at which to compute the density. + the density at . + + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The scale parameter a of the Burr distribution. Range: a > 0. + The first shape parameter c of the Burr distribution. Range: c > 0. + The second shape parameter k of the Burr distribution. Range: k > 0. + The location at which to compute the log density. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The scale parameter a of the Burr distribution. Range: a > 0. + The first shape parameter c of the Burr distribution. Range: c > 0. + The second shape parameter k of the Burr distribution. Range: k > 0. + The location at which to compute the cumulative distribution function. + the cumulative distribution at location . + + + + + Discrete Univariate Categorical distribution. + For details about this distribution, see + Wikipedia - Categorical distribution. This + distribution is sometimes called the Discrete distribution. + + + The distribution is parameterized by a vector of ratios: in other words, the parameter + does not have to be normalized and sum to 1. The reason is that some vectors can't be exactly normalized + to sum to 1 in floating point representation. + + + Support: 0..k where k = length(probability mass array)-1 + + + + + Initializes a new instance of the Categorical class. + + An array of nonnegative ratios: this array does not need to be normalized + as this is often impossible using floating point arithmetic. + If any of the probabilities are negative or do not sum to one. + + + + Initializes a new instance of the Categorical class. + + An array of nonnegative ratios: this array does not need to be normalized + as this is often impossible using floating point arithmetic. + The random number generator which is used to draw random samples. + If any of the probabilities are negative or do not sum to one. + + + + Initializes a new instance of the Categorical class from a . The distribution + will not be automatically updated when the histogram changes. The categorical distribution will have + one value for each bucket and a probability for that value proportional to the bucket count. + + The histogram from which to create the categorical variable. + + + + A string representation of the distribution. + + a string representation of the distribution. + + + + Checks whether the parameters of the distribution are valid. + + An array of nonnegative ratios: this array does not need to be normalized as this is often impossible using floating point arithmetic. + If any of the probabilities are negative returns false, or if the sum of parameters is 0.0; otherwise true + + + + Checks whether the parameters of the distribution are valid. + + An array of nonnegative ratios: this array does not need to be normalized as this is often impossible using floating point arithmetic. + If any of the probabilities are negative returns false, or if the sum of parameters is 0.0; otherwise true + + + + Gets the probability mass vector (non-negative ratios) of the multinomial. + + Sometimes the normalized probability vector cannot be represented exactly in a floating point representation. + + + + Gets or sets the random number generator which is used to draw random samples. + + + + + Gets the mean of the distribution. + + + + + Gets the standard deviation of the distribution. + + + + + Gets the variance of the distribution. + + + + + Gets the entropy of the distribution. + + + + + Gets the skewness of the distribution. + + Throws a . + + + + Gets the smallest element in the domain of the distributions which can be represented by an integer. + + + + + Gets the largest element in the domain of the distributions which can be represented by an integer. + + + + + Gets he mode of the distribution. + + Throws a . + + + + Gets the median of the distribution. + + + + + Computes the probability mass (PMF) at k, i.e. P(X = k). + + The location in the domain where we want to evaluate the probability mass function. + the probability mass at location . + + + + Computes the log probability mass (lnPMF) at k, i.e. ln(P(X = k)). + + The location in the domain where we want to evaluate the log probability mass function. + the log probability mass at location . + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + the cumulative distribution at location . + + + + Computes the inverse of the cumulative distribution function (InvCDF) for the distribution + at the given probability. + + A real number between 0 and 1. + An integer between 0 and the size of the categorical (exclusive), that corresponds to the inverse CDF for the given probability. + + + + Computes the probability mass (PMF) at k, i.e. P(X = k). + + The location in the domain where we want to evaluate the probability mass function. + An array of nonnegative ratios: this array does not need to be normalized + as this is often impossible using floating point arithmetic. + the probability mass at location . + + + + Computes the log probability mass (lnPMF) at k, i.e. ln(P(X = k)). + + The location in the domain where we want to evaluate the log probability mass function. + An array of nonnegative ratios: this array does not need to be normalized + as this is often impossible using floating point arithmetic. + the log probability mass at location . + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + An array of nonnegative ratios: this array does not need to be normalized + as this is often impossible using floating point arithmetic. + the cumulative distribution at location . + + + + + Computes the inverse of the cumulative distribution function (InvCDF) for the distribution + at the given probability. + + An array of nonnegative ratios: this array does not need to be normalized + as this is often impossible using floating point arithmetic. + A real number between 0 and 1. + An integer between 0 and the size of the categorical (exclusive), that corresponds to the inverse CDF for the given probability. + + + + Computes the inverse of the cumulative distribution function (InvCDF) for the distribution + at the given probability. + + An array corresponding to a CDF for a categorical distribution. Not assumed to be normalized. + A real number between 0 and 1. + An integer between 0 and the size of the categorical (exclusive), that corresponds to the inverse CDF for the given probability. + + + + Computes the cumulative distribution function. This method performs no parameter checking. + If the probability mass was normalized, the resulting cumulative distribution is normalized as well (up to numerical errors). + + An array of nonnegative ratios: this array does not need to be normalized + as this is often impossible using floating point arithmetic. + An array representing the unnormalized cumulative distribution function. + + + + Returns one trials from the categorical distribution. + + The random number generator to use. + The (unnormalized) cumulative distribution of the probability distribution. + One sample from the categorical distribution implied by . + + + + Samples a Binomially distributed random variable. + + The number of successful trials. + + + + Fills an array with samples generated from the distribution. + + + + + Samples an array of Bernoulli distributed random variables. + + a sequence of successful trial counts. + + + + Samples one categorical distributed random variable; also known as the Discrete distribution. + + The random number generator to use. + An array of nonnegative ratios. Not assumed to be normalized. + One random integer between 0 and the size of the categorical (exclusive). + + + + Samples a categorically distributed random variable. + + The random number generator to use. + An array of nonnegative ratios. Not assumed to be normalized. + random integers between 0 and the size of the categorical (exclusive). + + + + Fills an array with samples generated from the distribution. + + The random number generator to use. + The array to fill with the samples. + An array of nonnegative ratios. Not assumed to be normalized. + random integers between 0 and the size of the categorical (exclusive). + + + + Samples one categorical distributed random variable; also known as the Discrete distribution. + + An array of nonnegative ratios. Not assumed to be normalized. + One random integer between 0 and the size of the categorical (exclusive). + + + + Samples a categorically distributed random variable. + + An array of nonnegative ratios. Not assumed to be normalized. + random integers between 0 and the size of the categorical (exclusive). + + + + Fills an array with samples generated from the distribution. + + The array to fill with the samples. + An array of nonnegative ratios. Not assumed to be normalized. + random integers between 0 and the size of the categorical (exclusive). + + + + Samples one categorical distributed random variable; also known as the Discrete distribution. + + The random number generator to use. + An array of the cumulative distribution. Not assumed to be normalized. + One random integer between 0 and the size of the categorical (exclusive). + + + + Samples a categorically distributed random variable. + + The random number generator to use. + An array of the cumulative distribution. Not assumed to be normalized. + random integers between 0 and the size of the categorical (exclusive). + + + + Fills an array with samples generated from the distribution. + + The random number generator to use. + The array to fill with the samples. + An array of the cumulative distribution. Not assumed to be normalized. + random integers between 0 and the size of the categorical (exclusive). + + + + Samples one categorical distributed random variable; also known as the Discrete distribution. + + An array of the cumulative distribution. Not assumed to be normalized. + One random integer between 0 and the size of the categorical (exclusive). + + + + Samples a categorically distributed random variable. + + An array of the cumulative distribution. Not assumed to be normalized. + random integers between 0 and the size of the categorical (exclusive). + + + + Fills an array with samples generated from the distribution. + + The array to fill with the samples. + An array of the cumulative distribution. Not assumed to be normalized. + random integers between 0 and the size of the categorical (exclusive). + + + + Continuous Univariate Cauchy distribution. + The Cauchy distribution is a symmetric continuous probability distribution. For details about this distribution, see + Wikipedia - Cauchy distribution. + + + + + Initializes a new instance of the class with the location parameter set to 0 and the scale parameter set to 1 + + + + + Initializes a new instance of the class. + + The location (x0) of the distribution. + The scale (γ) of the distribution. Range: γ > 0. + + + + Initializes a new instance of the class. + + The location (x0) of the distribution. + The scale (γ) of the distribution. Range: γ > 0. + The random number generator which is used to draw random samples. + + + + A string representation of the distribution. + + a string representation of the distribution. + + + + Tests whether the provided values are valid parameters for this distribution. + + The location (x0) of the distribution. + The scale (γ) of the distribution. Range: γ > 0. + + + + Gets the location (x0) of the distribution. + + + + + Gets the scale (γ) of the distribution. Range: γ > 0. + + + + + Gets or sets the random number generator which is used to draw random samples. + + + + + Gets the mean of the distribution. + + + + + Gets the variance of the distribution. + + + + + Gets the standard deviation of the distribution. + + + + + Gets the entropy of the distribution. + + + + + Gets the skewness of the distribution. + + + + + Gets the mode of the distribution. + + + + + Gets the median of the distribution. + + + + + Gets the minimum of the distribution. + + + + + Gets the maximum of the distribution. + + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The location at which to compute the density. + the density at . + + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The location at which to compute the log density. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + the cumulative distribution at location . + + + + + Computes the inverse of the cumulative distribution function (InvCDF) for the distribution + at the given probability. This is also known as the quantile or percent point function. + + The location at which to compute the inverse cumulative density. + the inverse cumulative density at . + + + + + Draws a random sample from the distribution. + + A random number from this distribution. + + + + Fills an array with samples generated from the distribution. + + + + + Generates a sequence of samples from the Cauchy distribution. + + a sequence of samples from the distribution. + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The location (x0) of the distribution. + The scale (γ) of the distribution. Range: γ > 0. + The location at which to compute the density. + the density at . + + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The location (x0) of the distribution. + The scale (γ) of the distribution. Range: γ > 0. + The location at which to compute the density. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + The location (x0) of the distribution. + The scale (γ) of the distribution. Range: γ > 0. + the cumulative distribution at location . + + + + + Computes the inverse of the cumulative distribution function (InvCDF) for the distribution + at the given probability. This is also known as the quantile or percent point function. + + The location at which to compute the inverse cumulative density. + The location (x0) of the distribution. + The scale (γ) of the distribution. Range: γ > 0. + the inverse cumulative density at . + + + + + Generates a sample from the distribution. + + The random number generator to use. + The location (x0) of the distribution. + The scale (γ) of the distribution. Range: γ > 0. + a sample from the distribution. + + + + Generates a sequence of samples from the distribution. + + The random number generator to use. + The location (x0) of the distribution. + The scale (γ) of the distribution. Range: γ > 0. + a sequence of samples from the distribution. + + + + Fills an array with samples generated from the distribution. + + The random number generator to use. + The array to fill with the samples. + The location (x0) of the distribution. + The scale (γ) of the distribution. Range: γ > 0. + a sequence of samples from the distribution. + + + + Generates a sample from the distribution. + + The location (x0) of the distribution. + The scale (γ) of the distribution. Range: γ > 0. + a sample from the distribution. + + + + Generates a sequence of samples from the distribution. + + The location (x0) of the distribution. + The scale (γ) of the distribution. Range: γ > 0. + a sequence of samples from the distribution. + + + + Fills an array with samples generated from the distribution. + + The array to fill with the samples. + The location (x0) of the distribution. + The scale (γ) of the distribution. Range: γ > 0. + a sequence of samples from the distribution. + + + + Continuous Univariate Chi distribution. + This distribution is a continuous probability distribution. The distribution usually arises when a k-dimensional vector's orthogonal + components are independent and each follow a standard normal distribution. The length of the vector will + then have a chi distribution. + Wikipedia - Chi distribution. + + + + + Initializes a new instance of the class. + + The degrees of freedom (k) of the distribution. Range: k > 0. + + + + Initializes a new instance of the class. + + The degrees of freedom (k) of the distribution. Range: k > 0. + The random number generator which is used to draw random samples. + + + + A string representation of the distribution. + + a string representation of the distribution. + + + + Tests whether the provided values are valid parameters for this distribution. + + The degrees of freedom (k) of the distribution. Range: k > 0. + + + + Gets the degrees of freedom (k) of the Chi distribution. Range: k > 0. + + + + + Gets or sets the random number generator which is used to draw random samples. + + + + + Gets the mean of the distribution. + + + + + Gets the variance of the distribution. + + + + + Gets the standard deviation of the distribution. + + + + + Gets the entropy of the distribution. + + + + + Gets the skewness of the distribution. + + + + + Gets the mode of the distribution. + + + + + Gets the median of the distribution. + + + + + Gets the minimum of the distribution. + + + + + Gets the maximum of the distribution. + + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The location at which to compute the density. + the density at . + + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The location at which to compute the log density. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + the cumulative distribution at location . + + + + + Generates a sample from the Chi distribution. + + a sample from the distribution. + + + + Fills an array with samples generated from the distribution. + + + + + Generates a sequence of samples from the Chi distribution. + + a sequence of samples from the distribution. + + + + Samples the distribution. + + The random number generator to use. + The degrees of freedom (k) of the distribution. Range: k > 0. + a random number from the distribution. + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The degrees of freedom (k) of the distribution. Range: k > 0. + The location at which to compute the density. + the density at . + + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The degrees of freedom (k) of the distribution. Range: k > 0. + The location at which to compute the density. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + The degrees of freedom (k) of the distribution. Range: k > 0. + the cumulative distribution at location . + + + + + Generates a sample from the distribution. + + The random number generator to use. + The degrees of freedom (k) of the distribution. Range: k > 0. + a sample from the distribution. + + + + Generates a sequence of samples from the distribution. + + The random number generator to use. + The degrees of freedom (k) of the distribution. Range: k > 0. + a sequence of samples from the distribution. + + + + Fills an array with samples generated from the distribution. + + The random number generator to use. + The array to fill with the samples. + The degrees of freedom (k) of the distribution. Range: k > 0. + a sequence of samples from the distribution. + + + + Generates a sample from the distribution. + + The degrees of freedom (k) of the distribution. Range: k > 0. + a sample from the distribution. + + + + Generates a sequence of samples from the distribution. + + The degrees of freedom (k) of the distribution. Range: k > 0. + a sequence of samples from the distribution. + + + + Fills an array with samples generated from the distribution. + + The array to fill with the samples. + The degrees of freedom (k) of the distribution. Range: k > 0. + a sequence of samples from the distribution. + + + + Continuous Univariate Chi-Squared distribution. + This distribution is a sum of the squares of k independent standard normal random variables. + Wikipedia - ChiSquare distribution. + + + + + Initializes a new instance of the class. + + The degrees of freedom (k) of the distribution. Range: k > 0. + + + + Initializes a new instance of the class. + + The degrees of freedom (k) of the distribution. Range: k > 0. + The random number generator which is used to draw random samples. + + + + A string representation of the distribution. + + a string representation of the distribution. + + + + Tests whether the provided values are valid parameters for this distribution. + + The degrees of freedom (k) of the distribution. Range: k > 0. + + + + Gets the degrees of freedom (k) of the Chi-Squared distribution. Range: k > 0. + + + + + Gets or sets the random number generator which is used to draw random samples. + + + + + Gets the mean of the distribution. + + + + + Gets the variance of the distribution. + + + + + Gets the standard deviation of the distribution. + + + + + Gets the entropy of the distribution. + + + + + Gets the skewness of the distribution. + + + + + Gets the mode of the distribution. + + + + + Gets the median of the distribution. + + + + + Gets the minimum of the distribution. + + + + + Gets the maximum of the distribution. + + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The location at which to compute the density. + the density at . + + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The location at which to compute the log density. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + the cumulative distribution at location . + + + + + Computes the inverse of the cumulative distribution function (InvCDF) for the distribution + at the given probability. This is also known as the quantile or percent point function. + + The location at which to compute the inverse cumulative density. + the inverse cumulative density at . + + + + + Generates a sample from the ChiSquare distribution. + + a sample from the distribution. + + + + Fills an array with samples generated from the distribution. + + + + + Generates a sequence of samples from the ChiSquare distribution. + + a sequence of samples from the distribution. + + + + Samples the distribution. + + The random number generator to use. + The degrees of freedom (k) of the distribution. Range: k > 0. + a random number from the distribution. + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The degrees of freedom (k) of the distribution. Range: k > 0. + The location at which to compute the density. + the density at . + + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The degrees of freedom (k) of the distribution. Range: k > 0. + The location at which to compute the density. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + The degrees of freedom (k) of the distribution. Range: k > 0. + the cumulative distribution at location . + + + + + Computes the inverse of the cumulative distribution function (InvCDF) for the distribution + at the given probability. This is also known as the quantile or percent point function. + + The degrees of freedom (k) of the distribution. Range: k > 0. + The location at which to compute the inverse cumulative density. + the inverse cumulative density at . + + + + Generates a sample from the ChiSquare distribution. + + The random number generator to use. + The degrees of freedom (k) of the distribution. Range: k > 0. + a sample from the distribution. + + + + Generates a sequence of samples from the distribution. + + The random number generator to use. + The degrees of freedom (k) of the distribution. Range: k > 0. + a sample from the distribution. + + + + Fills an array with samples generated from the distribution. + + The random number generator to use. + The array to fill with the samples. + The degrees of freedom (k) of the distribution. Range: k > 0. + a sample from the distribution. + + + + Generates a sample from the ChiSquare distribution. + + The degrees of freedom (k) of the distribution. Range: k > 0. + a sample from the distribution. + + + + Generates a sequence of samples from the distribution. + + The degrees of freedom (k) of the distribution. Range: k > 0. + a sample from the distribution. + + + + Fills an array with samples generated from the distribution. + + The array to fill with the samples. + The degrees of freedom (k) of the distribution. Range: k > 0. + a sample from the distribution. + + + + Continuous Univariate Uniform distribution. + The continuous uniform distribution is a distribution over real numbers. For details about this distribution, see + Wikipedia - Continuous uniform distribution. + + + + + Initializes a new instance of the ContinuousUniform class with lower bound 0 and upper bound 1. + + + + + Initializes a new instance of the ContinuousUniform class with given lower and upper bounds. + + Lower bound. Range: lower ≤ upper. + Upper bound. Range: lower ≤ upper. + If the upper bound is smaller than the lower bound. + + + + Initializes a new instance of the ContinuousUniform class with given lower and upper bounds. + + Lower bound. Range: lower ≤ upper. + Upper bound. Range: lower ≤ upper. + The random number generator which is used to draw random samples. + If the upper bound is smaller than the lower bound. + + + + A string representation of the distribution. + + a string representation of the distribution. + + + + Tests whether the provided values are valid parameters for this distribution. + + Lower bound. Range: lower ≤ upper. + Upper bound. Range: lower ≤ upper. + + + + Gets the lower bound of the distribution. + + + + + Gets the upper bound of the distribution. + + + + + Gets or sets the random number generator which is used to draw random samples. + + + + + Gets the mean of the distribution. + + + + + Gets the variance of the distribution. + + + + + Gets the standard deviation of the distribution. + + + + + Gets the entropy of the distribution. + + + + + + Gets the skewness of the distribution. + + + + + Gets the mode of the distribution. + + + + + + Gets the median of the distribution. + + + + + + Gets the minimum of the distribution. + + + + + Gets the maximum of the distribution. + + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The location at which to compute the density. + the density at . + + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The location at which to compute the log density. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + the cumulative distribution at location . + + + + + Computes the inverse of the cumulative distribution function (InvCDF) for the distribution + at the given probability. This is also known as the quantile or percent point function. + + The location at which to compute the inverse cumulative density. + the inverse cumulative density at . + + + + + Generates a sample from the ContinuousUniform distribution. + + a sample from the distribution. + + + + Fills an array with samples generated from the distribution. + + + + + Generates a sequence of samples from the ContinuousUniform distribution. + + a sequence of samples from the distribution. + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + Lower bound. Range: lower ≤ upper. + Upper bound. Range: lower ≤ upper. + The location at which to compute the density. + the density at . + + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + Lower bound. Range: lower ≤ upper. + Upper bound. Range: lower ≤ upper. + The location at which to compute the density. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + Lower bound. Range: lower ≤ upper. + Upper bound. Range: lower ≤ upper. + the cumulative distribution at location . + + + + + Computes the inverse of the cumulative distribution function (InvCDF) for the distribution + at the given probability. This is also known as the quantile or percent point function. + + The location at which to compute the inverse cumulative density. + Lower bound. Range: lower ≤ upper. + Upper bound. Range: lower ≤ upper. + the inverse cumulative density at . + + + + + Generates a sample from the ContinuousUniform distribution. + + The random number generator to use. + Lower bound. Range: lower ≤ upper. + Upper bound. Range: lower ≤ upper. + a uniformly distributed sample. + + + + Generates a sequence of samples from the ContinuousUniform distribution. + + The random number generator to use. + Lower bound. Range: lower ≤ upper. + Upper bound. Range: lower ≤ upper. + a sequence of uniformly distributed samples. + + + + Fills an array with samples generated from the distribution. + + The random number generator to use. + The array to fill with the samples. + Lower bound. Range: lower ≤ upper. + Upper bound. Range: lower ≤ upper. + a sequence of samples from the distribution. + + + + Generates a sample from the ContinuousUniform distribution. + + Lower bound. Range: lower ≤ upper. + Upper bound. Range: lower ≤ upper. + a uniformly distributed sample. + + + + Generates a sequence of samples from the ContinuousUniform distribution. + + Lower bound. Range: lower ≤ upper. + Upper bound. Range: lower ≤ upper. + a sequence of uniformly distributed samples. + + + + Fills an array with samples generated from the distribution. + + The array to fill with the samples. + Lower bound. Range: lower ≤ upper. + Upper bound. Range: lower ≤ upper. + a sequence of samples from the distribution. + + + + Discrete Univariate Conway-Maxwell-Poisson distribution. + The Conway-Maxwell-Poisson distribution is a generalization of the Poisson, Geometric and Bernoulli + distributions. It is parameterized by two real numbers "lambda" and "nu". For + + nu = 0 the distribution reverts to a Geometric distribution + nu = 1 the distribution reverts to the Poisson distribution + nu -> infinity the distribution converges to a Bernoulli distribution + + This implementation will cache the value of the normalization constant. + Wikipedia - ConwayMaxwellPoisson distribution. + + + + + The mean of the distribution. + + + + + The variance of the distribution. + + + + + Caches the value of the normalization constant. + + + + + Since many properties of the distribution can only be computed approximately, the tolerance + level specifies how much error we accept. + + + + + Initializes a new instance of the class. + + The lambda (λ) parameter. Range: λ > 0. + The rate of decay (ν) parameter. Range: ν ≥ 0. + + + + Initializes a new instance of the class. + + The lambda (λ) parameter. Range: λ > 0. + The rate of decay (ν) parameter. Range: ν ≥ 0. + The random number generator which is used to draw random samples. + + + + Returns a that represents this instance. + + A that represents this instance. + + + + Tests whether the provided values are valid parameters for this distribution. + + The lambda (λ) parameter. Range: λ > 0. + The rate of decay (ν) parameter. Range: ν ≥ 0. + + + + Gets the lambda (λ) parameter. Range: λ > 0. + + + + + Gets the rate of decay (ν) parameter. Range: ν ≥ 0. + + + + + Gets or sets the random number generator which is used to draw random samples. + + + + + Gets the mean of the distribution. + + + + + Gets the variance of the distribution. + + + + + Gets the standard deviation of the distribution. + + + + + Gets the entropy of the distribution. + + + + + Gets the skewness of the distribution. + + + + + Gets the mode of the distribution + + + + + Gets the median of the distribution. + + + + + Gets the smallest element in the domain of the distributions which can be represented by an integer. + + + + + Gets the largest element in the domain of the distributions which can be represented by an integer. + + + + + Computes the probability mass (PMF) at k, i.e. P(X = k). + + The location in the domain where we want to evaluate the probability mass function. + the probability mass at location . + + + + Computes the log probability mass (lnPMF) at k, i.e. ln(P(X = k)). + + The location in the domain where we want to evaluate the log probability mass function. + the log probability mass at location . + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + the cumulative distribution at location . + + + + Computes the probability mass (PMF) at k, i.e. P(X = k). + + The location in the domain where we want to evaluate the probability mass function. + The lambda (λ) parameter. Range: λ > 0. + The rate of decay (ν) parameter. Range: ν ≥ 0. + the probability mass at location . + + + + Computes the log probability mass (lnPMF) at k, i.e. ln(P(X = k)). + + The location in the domain where we want to evaluate the log probability mass function. + The lambda (λ) parameter. Range: λ > 0. + The rate of decay (ν) parameter. Range: ν ≥ 0. + the log probability mass at location . + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + The lambda (λ) parameter. Range: λ > 0. + The rate of decay (ν) parameter. Range: ν ≥ 0. + the cumulative distribution at location . + + + + + Gets the normalization constant of the Conway-Maxwell-Poisson distribution. + + + + + Computes an approximate normalization constant for the CMP distribution. + + The lambda (λ) parameter for the CMP distribution. + The rate of decay (ν) parameter for the CMP distribution. + + an approximate normalization constant for the CMP distribution. + + + + + Returns one trials from the distribution. + + The random number generator to use. + The lambda (λ) parameter. Range: λ > 0. + The rate of decay (ν) parameter. Range: ν ≥ 0. + The z parameter. + + One sample from the distribution implied by , , and . + + + + + Samples a Conway-Maxwell-Poisson distributed random variable. + + a sample from the distribution. + + + + Fills an array with samples generated from the distribution. + + + + + Samples a sequence of a Conway-Maxwell-Poisson distributed random variables. + + + a sequence of samples from a Conway-Maxwell-Poisson distribution. + + + + + Samples a random variable. + + The random number generator to use. + The lambda (λ) parameter. Range: λ > 0. + The rate of decay (ν) parameter. Range: ν ≥ 0. + + + + Samples a sequence of this random variable. + + The random number generator to use. + The lambda (λ) parameter. Range: λ > 0. + The rate of decay (ν) parameter. Range: ν ≥ 0. + + + + Fills an array with samples generated from the distribution. + + The random number generator to use. + The array to fill with the samples. + The lambda (λ) parameter. Range: λ > 0. + The rate of decay (ν) parameter. Range: ν ≥ 0. + + + + Samples a random variable. + + The lambda (λ) parameter. Range: λ > 0. + The rate of decay (ν) parameter. Range: ν ≥ 0. + + + + Samples a sequence of this random variable. + + The lambda (λ) parameter. Range: λ > 0. + The rate of decay (ν) parameter. Range: ν ≥ 0. + + + + Fills an array with samples generated from the distribution. + + The array to fill with the samples. + The lambda (λ) parameter. Range: λ > 0. + The rate of decay (ν) parameter. Range: ν ≥ 0. + + + + Multivariate Dirichlet distribution. For details about this distribution, see + Wikipedia - Dirichlet distribution. + + + + + Initializes a new instance of the Dirichlet class. The distribution will + be initialized with the default random number generator. + + An array with the Dirichlet parameters. + + + + Initializes a new instance of the Dirichlet class. The distribution will + be initialized with the default random number generator. + + An array with the Dirichlet parameters. + The random number generator which is used to draw random samples. + + + + Initializes a new instance of the class. + random number generator. + The value of each parameter of the Dirichlet distribution. + The dimension of the Dirichlet distribution. + + + + Initializes a new instance of the class. + random number generator. + The value of each parameter of the Dirichlet distribution. + The dimension of the Dirichlet distribution. + The random number generator which is used to draw random samples. + + + + Returns a that represents this instance. + + + A that represents this instance. + + + + + Tests whether the provided values are valid parameters for this distribution. + No parameter can be less than zero and at least one parameter should be larger than zero. + + The parameters of the Dirichlet distribution. + + + + Gets or sets the parameters of the Dirichlet distribution. + + + + + Gets or sets the random number generator which is used to draw random samples. + + + + + Gets the dimension of the Dirichlet distribution. + + + + + Gets the sum of the Dirichlet parameters. + + + + + Gets the mean of the Dirichlet distribution. + + + + + Gets the variance of the Dirichlet distribution. + + + + + Gets the entropy of the distribution. + + + + + Computes the density of the distribution. + + The locations at which to compute the density. + the density at . + The Dirichlet distribution requires that the sum of the components of x equals 1. + You can also leave out the last component, and it will be computed from the others. + + + + Computes the log density of the distribution. + + The locations at which to compute the density. + the density at . + + + + Samples a Dirichlet distributed random vector. + + A sample from this distribution. + + + + Samples a Dirichlet distributed random vector. + + The random number generator to use. + The Dirichlet distribution parameter. + a sample from the distribution. + + + + Discrete Univariate Uniform distribution. + The discrete uniform distribution is a distribution over integers. The distribution + is parameterized by a lower and upper bound (both inclusive). + Wikipedia - Discrete uniform distribution. + + + + + Initializes a new instance of the DiscreteUniform class. + + Lower bound, inclusive. Range: lower ≤ upper. + Upper bound, inclusive. Range: lower ≤ upper. + + + + Initializes a new instance of the DiscreteUniform class. + + Lower bound, inclusive. Range: lower ≤ upper. + Upper bound, inclusive. Range: lower ≤ upper. + The random number generator which is used to draw random samples. + + + + Returns a that represents this instance. + + + A that represents this instance. + + + + + Tests whether the provided values are valid parameters for this distribution. + + Lower bound, inclusive. Range: lower ≤ upper. + Upper bound, inclusive. Range: lower ≤ upper. + + + + Gets the inclusive lower bound of the probability distribution. + + + + + Gets the inclusive upper bound of the probability distribution. + + + + + Gets or sets the random number generator which is used to draw random samples. + + + + + Gets the mean of the distribution. + + + + + Gets the standard deviation of the distribution. + + + + + Gets the variance of the distribution. + + + + + Gets the entropy of the distribution. + + + + + Gets the skewness of the distribution. + + + + + Gets the smallest element in the domain of the distributions which can be represented by an integer. + + + + + Gets the largest element in the domain of the distributions which can be represented by an integer. + + + + + Gets the mode of the distribution; since every element in the domain has the same probability this method returns the middle one. + + + + + Gets the median of the distribution. + + + + + Computes the probability mass (PMF) at k, i.e. P(X = k). + + The location in the domain where we want to evaluate the probability mass function. + the probability mass at location . + + + + Computes the log probability mass (lnPMF) at k, i.e. ln(P(X = k)). + + The location in the domain where we want to evaluate the log probability mass function. + the log probability mass at location . + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + the cumulative distribution at location . + + + + Computes the probability mass (PMF) at k, i.e. P(X = k). + + The location in the domain where we want to evaluate the probability mass function. + Lower bound, inclusive. Range: lower ≤ upper. + Upper bound, inclusive. Range: lower ≤ upper. + the probability mass at location . + + + + Computes the log probability mass (lnPMF) at k, i.e. ln(P(X = k)). + + The location in the domain where we want to evaluate the log probability mass function. + Lower bound, inclusive. Range: lower ≤ upper. + Upper bound, inclusive. Range: lower ≤ upper. + the log probability mass at location . + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + Lower bound, inclusive. Range: lower ≤ upper. + Upper bound, inclusive. Range: lower ≤ upper. + the cumulative distribution at location . + + + + + Generates one sample from the discrete uniform distribution. This method does not do any parameter checking. + + The random source to use. + Lower bound, inclusive. Range: lower ≤ upper. + Upper bound, inclusive. Range: lower ≤ upper. + A random sample from the discrete uniform distribution. + + + + Draws a random sample from the distribution. + + a sample from the distribution. + + + + Fills an array with samples generated from the distribution. + + + + + Samples an array of uniformly distributed random variables. + + a sequence of samples from the distribution. + + + + Samples a uniformly distributed random variable. + + The random number generator to use. + Lower bound, inclusive. Range: lower ≤ upper. + Upper bound, inclusive. Range: lower ≤ upper. + A sample from the discrete uniform distribution. + + + + Samples a sequence of uniformly distributed random variables. + + The random number generator to use. + Lower bound, inclusive. Range: lower ≤ upper. + Upper bound, inclusive. Range: lower ≤ upper. + a sequence of samples from the discrete uniform distribution. + + + + Fills an array with samples generated from the distribution. + + The random number generator to use. + The array to fill with the samples. + Lower bound, inclusive. Range: lower ≤ upper. + Upper bound, inclusive. Range: lower ≤ upper. + a sequence of samples from the discrete uniform distribution. + + + + Samples a uniformly distributed random variable. + + Lower bound, inclusive. Range: lower ≤ upper. + Upper bound, inclusive. Range: lower ≤ upper. + A sample from the discrete uniform distribution. + + + + Samples a sequence of uniformly distributed random variables. + + Lower bound, inclusive. Range: lower ≤ upper. + Upper bound, inclusive. Range: lower ≤ upper. + a sequence of samples from the discrete uniform distribution. + + + + Fills an array with samples generated from the distribution. + + The array to fill with the samples. + Lower bound, inclusive. Range: lower ≤ upper. + Upper bound, inclusive. Range: lower ≤ upper. + a sequence of samples from the discrete uniform distribution. + + + + Continuous Univariate Erlang distribution. + This distribution is a continuous probability distribution with wide applicability primarily due to its + relation to the exponential and Gamma distributions. + Wikipedia - Erlang distribution. + + + + + Initializes a new instance of the class. + + The shape (k) of the Erlang distribution. Range: k ≥ 0. + The rate or inverse scale (λ) of the Erlang distribution. Range: λ ≥ 0. + + + + Initializes a new instance of the class. + + The shape (k) of the Erlang distribution. Range: k ≥ 0. + The rate or inverse scale (λ) of the Erlang distribution. Range: λ ≥ 0. + The random number generator which is used to draw random samples. + + + + Constructs a Erlang distribution from a shape and scale parameter. The distribution will + be initialized with the default random number generator. + + The shape (k) of the Erlang distribution. Range: k ≥ 0. + The scale (μ) of the Erlang distribution. Range: μ ≥ 0. + The random number generator which is used to draw random samples. Optional, can be null. + + + + Constructs a Erlang distribution from a shape and inverse scale parameter. The distribution will + be initialized with the default random number generator. + + The shape (k) of the Erlang distribution. Range: k ≥ 0. + The rate or inverse scale (λ) of the Erlang distribution. Range: λ ≥ 0. + The random number generator which is used to draw random samples. Optional, can be null. + + + + A string representation of the distribution. + + a string representation of the distribution. + + + + Tests whether the provided values are valid parameters for this distribution. + + The shape (k) of the Erlang distribution. Range: k ≥ 0. + The rate or inverse scale (λ) of the Erlang distribution. Range: λ ≥ 0. + + + + Gets the shape (k) of the Erlang distribution. Range: k ≥ 0. + + + + + Gets the rate or inverse scale (λ) of the Erlang distribution. Range: λ ≥ 0. + + + + + Gets the scale of the Erlang distribution. + + + + + Gets or sets the random number generator which is used to draw random samples. + + + + + Gets the mean of the distribution. + + + + + Gets the variance of the distribution. + + + + + Gets the standard deviation of the distribution. + + + + + Gets the entropy of the distribution. + + + + + Gets the skewness of the distribution. + + + + + Gets the mode of the distribution. + + + + + Gets the median of the distribution. + + + + + Gets the minimum value. + + + + + Gets the Maximum value. + + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The location at which to compute the density. + the density at . + + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The location at which to compute the log density. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + the cumulative distribution at location . + + + + + Generates a sample from the Erlang distribution. + + a sample from the distribution. + + + + Fills an array with samples generated from the distribution. + + + + + Generates a sequence of samples from the Erlang distribution. + + a sequence of samples from the distribution. + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The shape (k) of the Erlang distribution. Range: k ≥ 0. + The rate or inverse scale (λ) of the Erlang distribution. Range: λ ≥ 0. + The location at which to compute the density. + the density at . + + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The shape (k) of the Erlang distribution. Range: k ≥ 0. + The rate or inverse scale (λ) of the Erlang distribution. Range: λ ≥ 0. + The location at which to compute the density. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + The shape (k) of the Erlang distribution. Range: k ≥ 0. + The rate or inverse scale (λ) of the Erlang distribution. Range: λ ≥ 0. + the cumulative distribution at location . + + + + + Generates a sample from the distribution. + + The random number generator to use. + The shape (k) of the Erlang distribution. Range: k ≥ 0. + The rate or inverse scale (λ) of the Erlang distribution. Range: λ ≥ 0. + a sample from the distribution. + + + + Generates a sequence of samples from the distribution. + + The random number generator to use. + The shape (k) of the Erlang distribution. Range: k ≥ 0. + The rate or inverse scale (λ) of the Erlang distribution. Range: λ ≥ 0. + a sequence of samples from the distribution. + + + + Fills an array with samples generated from the distribution. + + The random number generator to use. + The array to fill with the samples. + The shape (k) of the Erlang distribution. Range: k ≥ 0. + The rate or inverse scale (λ) of the Erlang distribution. Range: λ ≥ 0. + a sequence of samples from the distribution. + + + + Generates a sample from the distribution. + + The shape (k) of the Erlang distribution. Range: k ≥ 0. + The rate or inverse scale (λ) of the Erlang distribution. Range: λ ≥ 0. + a sample from the distribution. + + + + Generates a sequence of samples from the distribution. + + The shape (k) of the Erlang distribution. Range: k ≥ 0. + The rate or inverse scale (λ) of the Erlang distribution. Range: λ ≥ 0. + a sequence of samples from the distribution. + + + + Fills an array with samples generated from the distribution. + + The array to fill with the samples. + The shape (k) of the Erlang distribution. Range: k ≥ 0. + The rate or inverse scale (λ) of the Erlang distribution. Range: λ ≥ 0. + a sequence of samples from the distribution. + + + + Continuous Univariate Exponential distribution. + The exponential distribution is a distribution over the real numbers parameterized by one non-negative parameter. + Wikipedia - exponential distribution. + + + + + Initializes a new instance of the class. + + The rate (λ) parameter of the distribution. Range: λ ≥ 0. + + + + Initializes a new instance of the class. + + The rate (λ) parameter of the distribution. Range: λ ≥ 0. + The random number generator which is used to draw random samples. + + + + A string representation of the distribution. + + a string representation of the distribution. + + + + Tests whether the provided values are valid parameters for this distribution. + + The rate (λ) parameter of the distribution. Range: λ ≥ 0. + + + + Gets the rate (λ) parameter of the distribution. Range: λ ≥ 0. + + + + + Gets or sets the random number generator which is used to draw random samples. + + + + + Gets the mean of the distribution. + + + + + Gets the variance of the distribution. + + + + + Gets the standard deviation of the distribution. + + + + + Gets the entropy of the distribution. + + + + + Gets the skewness of the distribution. + + + + + Gets the mode of the distribution. + + + + + Gets the median of the distribution. + + + + + Gets the minimum of the distribution. + + + + + Gets the maximum of the distribution. + + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The location at which to compute the density. + the density at . + + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The location at which to compute the log density. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + the cumulative distribution at location . + + + + + Computes the inverse of the cumulative distribution function (InvCDF) for the distribution + at the given probability. This is also known as the quantile or percent point function. + + The location at which to compute the inverse cumulative density. + the inverse cumulative density at . + + + + + Draws a random sample from the distribution. + + A random number from this distribution. + + + + Fills an array with samples generated from the distribution. + + + + + Generates a sequence of samples from the Exponential distribution. + + a sequence of samples from the distribution. + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The rate (λ) parameter of the distribution. Range: λ ≥ 0. + The location at which to compute the density. + the density at . + + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The rate (λ) parameter of the distribution. Range: λ ≥ 0. + The location at which to compute the density. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + The rate (λ) parameter of the distribution. Range: λ ≥ 0. + the cumulative distribution at location . + + + + + Computes the inverse of the cumulative distribution function (InvCDF) for the distribution + at the given probability. This is also known as the quantile or percent point function. + + The location at which to compute the inverse cumulative density. + The rate (λ) parameter of the distribution. Range: λ ≥ 0. + the inverse cumulative density at . + + + + + Draws a random sample from the distribution. + + The random number generator to use. + The rate (λ) parameter of the distribution. Range: λ ≥ 0. + A random number from this distribution. + + + + Fills an array with samples generated from the distribution. + + The random number generator to use. + The array to fill with the samples. + The rate (λ) parameter of the distribution. Range: λ ≥ 0. + a sequence of samples from the distribution. + + + + Generates a sequence of samples from the Exponential distribution. + + The random number generator to use. + The rate (λ) parameter of the distribution. Range: λ ≥ 0. + a sequence of samples from the distribution. + + + + Draws a random sample from the distribution. + + The rate (λ) parameter of the distribution. Range: λ ≥ 0. + A random number from this distribution. + + + + Fills an array with samples generated from the distribution. + + The array to fill with the samples. + The rate (λ) parameter of the distribution. Range: λ ≥ 0. + a sequence of samples from the distribution. + + + + Generates a sequence of samples from the Exponential distribution. + + The rate (λ) parameter of the distribution. Range: λ ≥ 0. + a sequence of samples from the distribution. + + + + Continuous Univariate F-distribution, also known as Fisher-Snedecor distribution. + For details about this distribution, see + Wikipedia - FisherSnedecor distribution. + + + + + Initializes a new instance of the class. + + The first degree of freedom (d1) of the distribution. Range: d1 > 0. + The second degree of freedom (d2) of the distribution. Range: d2 > 0. + + + + Initializes a new instance of the class. + + The first degree of freedom (d1) of the distribution. Range: d1 > 0. + The second degree of freedom (d2) of the distribution. Range: d2 > 0. + The random number generator which is used to draw random samples. + + + + A string representation of the distribution. + + a string representation of the distribution. + + + + Tests whether the provided values are valid parameters for this distribution. + + The first degree of freedom (d1) of the distribution. Range: d1 > 0. + The second degree of freedom (d2) of the distribution. Range: d2 > 0. + + + + Gets the first degree of freedom (d1) of the distribution. Range: d1 > 0. + + + + + Gets the second degree of freedom (d2) of the distribution. Range: d2 > 0. + + + + + Gets or sets the random number generator which is used to draw random samples. + + + + + Gets the mean of the distribution. + + + + + Gets the variance of the distribution. + + + + + Gets the standard deviation of the distribution. + + + + + Gets the entropy of the distribution. + + + + + Gets the skewness of the distribution. + + + + + Gets the mode of the distribution. + + + + + Gets the median of the distribution. + + + + + Gets the minimum of the distribution. + + + + + Gets the maximum of the distribution. + + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The location at which to compute the density. + the density at . + + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The location at which to compute the log density. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + the cumulative distribution at location . + + + + + Computes the inverse of the cumulative distribution function (InvCDF) for the distribution + at the given probability. This is also known as the quantile or percent point function. + + The location at which to compute the inverse cumulative density. + the inverse cumulative density at . + + WARNING: currently not an explicit implementation, hence slow and unreliable. + + + + Generates a sample from the FisherSnedecor distribution. + + a sample from the distribution. + + + + Fills an array with samples generated from the distribution. + + + + + Generates a sequence of samples from the FisherSnedecor distribution. + + a sequence of samples from the distribution. + + + + Generates one sample from the FisherSnedecor distribution without parameter checking. + + The random number generator to use. + The first degree of freedom (d1) of the distribution. Range: d1 > 0. + The second degree of freedom (d2) of the distribution. Range: d2 > 0. + a FisherSnedecor distributed random number. + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The first degree of freedom (d1) of the distribution. Range: d1 > 0. + The second degree of freedom (d2) of the distribution. Range: d2 > 0. + The location at which to compute the density. + the density at . + + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The first degree of freedom (d1) of the distribution. Range: d1 > 0. + The second degree of freedom (d2) of the distribution. Range: d2 > 0. + The location at which to compute the density. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + The first degree of freedom (d1) of the distribution. Range: d1 > 0. + The second degree of freedom (d2) of the distribution. Range: d2 > 0. + the cumulative distribution at location . + + + + + Computes the inverse of the cumulative distribution function (InvCDF) for the distribution + at the given probability. This is also known as the quantile or percent point function. + + The location at which to compute the inverse cumulative density. + The first degree of freedom (d1) of the distribution. Range: d1 > 0. + The second degree of freedom (d2) of the distribution. Range: d2 > 0. + the inverse cumulative density at . + + WARNING: currently not an explicit implementation, hence slow and unreliable. + + + + Generates a sample from the distribution. + + The random number generator to use. + The first degree of freedom (d1) of the distribution. Range: d1 > 0. + The second degree of freedom (d2) of the distribution. Range: d2 > 0. + a sample from the distribution. + + + + Generates a sequence of samples from the distribution. + + The random number generator to use. + The first degree of freedom (d1) of the distribution. Range: d1 > 0. + The second degree of freedom (d2) of the distribution. Range: d2 > 0. + a sequence of samples from the distribution. + + + + Fills an array with samples generated from the distribution. + + The random number generator to use. + The array to fill with the samples. + The first degree of freedom (d1) of the distribution. Range: d1 > 0. + The second degree of freedom (d2) of the distribution. Range: d2 > 0. + a sequence of samples from the distribution. + + + + Generates a sample from the distribution. + + The first degree of freedom (d1) of the distribution. Range: d1 > 0. + The second degree of freedom (d2) of the distribution. Range: d2 > 0. + a sample from the distribution. + + + + Generates a sequence of samples from the distribution. + + The first degree of freedom (d1) of the distribution. Range: d1 > 0. + The second degree of freedom (d2) of the distribution. Range: d2 > 0. + a sequence of samples from the distribution. + + + + Fills an array with samples generated from the distribution. + + The array to fill with the samples. + The first degree of freedom (d1) of the distribution. Range: d1 > 0. + The second degree of freedom (d2) of the distribution. Range: d2 > 0. + a sequence of samples from the distribution. + + + + Continuous Univariate Gamma distribution. + For details about this distribution, see + Wikipedia - Gamma distribution. + + + The Gamma distribution is parametrized by a shape and inverse scale parameter. When we want + to specify a Gamma distribution which is a point distribution we set the shape parameter to be the + location of the point distribution and the inverse scale as positive infinity. The distribution + with shape and inverse scale both zero is undefined. + + Random number generation for the Gamma distribution is based on the algorithm in: + "A Simple Method for Generating Gamma Variables" - Marsaglia & Tsang + ACM Transactions on Mathematical Software, Vol. 26, No. 3, September 2000, Pages 363–372. + + + + + Initializes a new instance of the Gamma class. + + The shape (k, α) of the Gamma distribution. Range: α ≥ 0. + The rate or inverse scale (β) of the Gamma distribution. Range: β ≥ 0. + + + + Initializes a new instance of the Gamma class. + + The shape (k, α) of the Gamma distribution. Range: α ≥ 0. + The rate or inverse scale (β) of the Gamma distribution. Range: β ≥ 0. + The random number generator which is used to draw random samples. + + + + Constructs a Gamma distribution from a shape and scale parameter. The distribution will + be initialized with the default random number generator. + + The shape (k) of the Gamma distribution. Range: k ≥ 0. + The scale (θ) of the Gamma distribution. Range: θ ≥ 0 + The random number generator which is used to draw random samples. Optional, can be null. + + + + Constructs a Gamma distribution from a shape and inverse scale parameter. The distribution will + be initialized with the default random number generator. + + The shape (k, α) of the Gamma distribution. Range: α ≥ 0. + The rate or inverse scale (β) of the Gamma distribution. Range: β ≥ 0. + The random number generator which is used to draw random samples. Optional, can be null. + + + + A string representation of the distribution. + + a string representation of the distribution. + + + + Tests whether the provided values are valid parameters for this distribution. + + The shape (k, α) of the Gamma distribution. Range: α ≥ 0. + The rate or inverse scale (β) of the Gamma distribution. Range: β ≥ 0. + + + + Gets or sets the shape (k, α) of the Gamma distribution. Range: α ≥ 0. + + + + + Gets or sets the rate or inverse scale (β) of the Gamma distribution. Range: β ≥ 0. + + + + + Gets or sets the scale (θ) of the Gamma distribution. + + + + + Gets or sets the random number generator which is used to draw random samples. + + + + + Gets the mean of the Gamma distribution. + + + + + Gets the variance of the Gamma distribution. + + + + + Gets the standard deviation of the Gamma distribution. + + + + + Gets the entropy of the Gamma distribution. + + + + + Gets the skewness of the Gamma distribution. + + + + + Gets the mode of the Gamma distribution. + + + + + Gets the median of the Gamma distribution. + + + + + Gets the minimum of the Gamma distribution. + + + + + Gets the maximum of the Gamma distribution. + + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The location at which to compute the density. + the density at . + + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The location at which to compute the log density. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + the cumulative distribution at location . + + + + + Computes the inverse of the cumulative distribution function (InvCDF) for the distribution + at the given probability. This is also known as the quantile or percent point function. + + The location at which to compute the inverse cumulative density. + the inverse cumulative density at . + + + + + Generates a sample from the Gamma distribution. + + a sample from the distribution. + + + + Fills an array with samples generated from the distribution. + + + + + Generates a sequence of samples from the Gamma distribution. + + a sequence of samples from the distribution. + + + + Sampling implementation based on: + "A Simple Method for Generating Gamma Variables" - Marsaglia & Tsang + ACM Transactions on Mathematical Software, Vol. 26, No. 3, September 2000, Pages 363–372. + This method performs no parameter checks. + + The random number generator to use. + The shape (k, α) of the Gamma distribution. Range: α ≥ 0. + The rate or inverse scale (β) of the Gamma distribution. Range: β ≥ 0. + A sample from a Gamma distributed random variable. + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The shape (k, α) of the Gamma distribution. Range: α ≥ 0. + The rate or inverse scale (β) of the Gamma distribution. Range: β ≥ 0. + The location at which to compute the density. + the density at . + + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The shape (k, α) of the Gamma distribution. Range: α ≥ 0. + The rate or inverse scale (β) of the Gamma distribution. Range: β ≥ 0. + The location at which to compute the density. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + The shape (k, α) of the Gamma distribution. Range: α ≥ 0. + The rate or inverse scale (β) of the Gamma distribution. Range: β ≥ 0. + the cumulative distribution at location . + + + + + Computes the inverse of the cumulative distribution function (InvCDF) for the distribution + at the given probability. This is also known as the quantile or percent point function. + + The location at which to compute the inverse cumulative density. + The shape (k, α) of the Gamma distribution. Range: α ≥ 0. + The rate or inverse scale (β) of the Gamma distribution. Range: β ≥ 0. + the inverse cumulative density at . + + + + + Generates a sample from the Gamma distribution. + + The random number generator to use. + The shape (k, α) of the Gamma distribution. Range: α ≥ 0. + The rate or inverse scale (β) of the Gamma distribution. Range: β ≥ 0. + a sample from the distribution. + + + + Generates a sequence of samples from the Gamma distribution. + + The random number generator to use. + The shape (k, α) of the Gamma distribution. Range: α ≥ 0. + The rate or inverse scale (β) of the Gamma distribution. Range: β ≥ 0. + a sequence of samples from the distribution. + + + + Fills an array with samples generated from the distribution. + + The random number generator to use. + The array to fill with the samples. + The shape (k, α) of the Gamma distribution. Range: α ≥ 0. + The rate or inverse scale (β) of the Gamma distribution. Range: β ≥ 0. + a sequence of samples from the distribution. + + + + Generates a sample from the Gamma distribution. + + The shape (k, α) of the Gamma distribution. Range: α ≥ 0. + The rate or inverse scale (β) of the Gamma distribution. Range: β ≥ 0. + a sample from the distribution. + + + + Generates a sequence of samples from the Gamma distribution. + + The shape (k, α) of the Gamma distribution. Range: α ≥ 0. + The rate or inverse scale (β) of the Gamma distribution. Range: β ≥ 0. + a sequence of samples from the distribution. + + + + Fills an array with samples generated from the distribution. + + The array to fill with the samples. + The shape (k, α) of the Gamma distribution. Range: α ≥ 0. + The rate or inverse scale (β) of the Gamma distribution. Range: β ≥ 0. + a sequence of samples from the distribution. + + + + Discrete Univariate Geometric distribution. + The Geometric distribution is a distribution over positive integers parameterized by one positive real number. + This implementation of the Geometric distribution will never generate 0's. + Wikipedia - geometric distribution. + + + + + Initializes a new instance of the Geometric class. + + The probability (p) of generating one. Range: 0 ≤ p ≤ 1. + + + + Initializes a new instance of the Geometric class. + + The probability (p) of generating one. Range: 0 ≤ p ≤ 1. + The random number generator which is used to draw random samples. + + + + Returns a that represents this instance. + + A that represents this instance. + + + + Tests whether the provided values are valid parameters for this distribution. + + The probability (p) of generating one. Range: 0 ≤ p ≤ 1. + + + + Gets the probability of generating a one. Range: 0 ≤ p ≤ 1. + + + + + Gets or sets the random number generator which is used to draw random samples. + + + + + Gets the mean of the distribution. + + + + + Gets the variance of the distribution. + + + + + Gets the standard deviation of the distribution. + + + + + Gets the entropy of the distribution. + + + + + Gets the skewness of the distribution. + + Throws a not supported exception. + + + + Gets the mode of the distribution. + + + + + Gets the median of the distribution. + + + + + Gets the smallest element in the domain of the distributions which can be represented by an integer. + + + + + Gets the largest element in the domain of the distributions which can be represented by an integer. + + + + + Computes the probability mass (PMF) at k, i.e. P(X = k). + + The location in the domain where we want to evaluate the probability mass function. + the probability mass at location . + + + + Computes the log probability mass (lnPMF) at k, i.e. ln(P(X = k)). + + The location in the domain where we want to evaluate the log probability mass function. + the log probability mass at location . + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + the cumulative distribution at location . + + + + Computes the probability mass (PMF) at k, i.e. P(X = k). + + The location in the domain where we want to evaluate the probability mass function. + The probability (p) of generating one. Range: 0 ≤ p ≤ 1. + the probability mass at location . + + + + Computes the log probability mass (lnPMF) at k, i.e. ln(P(X = k)). + + The location in the domain where we want to evaluate the log probability mass function. + The probability (p) of generating one. Range: 0 ≤ p ≤ 1. + the log probability mass at location . + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + The probability (p) of generating one. Range: 0 ≤ p ≤ 1. + the cumulative distribution at location . + + + + + Returns one sample from the distribution. + + The random number generator to use. + The probability (p) of generating one. Range: 0 ≤ p ≤ 1. + One sample from the distribution implied by . + + + + Samples a Geometric distributed random variable. + + A sample from the Geometric distribution. + + + + Fills an array with samples generated from the distribution. + + + + + Samples an array of Geometric distributed random variables. + + a sequence of samples from the distribution. + + + + Samples a random variable. + + The random number generator to use. + The probability (p) of generating one. Range: 0 ≤ p ≤ 1. + + + + Samples a sequence of this random variable. + + The random number generator to use. + The probability (p) of generating one. Range: 0 ≤ p ≤ 1. + + + + Fills an array with samples generated from the distribution. + + The random number generator to use. + The array to fill with the samples. + The probability (p) of generating one. Range: 0 ≤ p ≤ 1. + + + + Samples a random variable. + + The probability (p) of generating one. Range: 0 ≤ p ≤ 1. + + + + Samples a sequence of this random variable. + + The probability (p) of generating one. Range: 0 ≤ p ≤ 1. + + + + Fills an array with samples generated from the distribution. + + The array to fill with the samples. + The probability (p) of generating one. Range: 0 ≤ p ≤ 1. + + + + Discrete Univariate Hypergeometric distribution. + This distribution is a discrete probability distribution that describes the number of successes in a sequence + of n draws from a finite population without replacement, just as the binomial distribution + describes the number of successes for draws with replacement + Wikipedia - Hypergeometric distribution. + + + + + Initializes a new instance of the Hypergeometric class. + + The size of the population (N). + The number successes within the population (K, M). + The number of draws without replacement (n). + + + + Initializes a new instance of the Hypergeometric class. + + The size of the population (N). + The number successes within the population (K, M). + The number of draws without replacement (n). + The random number generator which is used to draw random samples. + + + + Returns a that represents this instance. + + + A that represents this instance. + + + + + Tests whether the provided values are valid parameters for this distribution. + + The size of the population (N). + The number successes within the population (K, M). + The number of draws without replacement (n). + + + + Gets or sets the random number generator which is used to draw random samples. + + + + + Gets the size of the population (N). + + + + + Gets the number of draws without replacement (n). + + + + + Gets the number successes within the population (K, M). + + + + + Gets the mean of the distribution. + + + + + Gets the variance of the distribution. + + + + + Gets the standard deviation of the distribution. + + + + + Gets the entropy of the distribution. + + + + + Gets the skewness of the distribution. + + + + + Gets the mode of the distribution. + + + + + Gets the median of the distribution. + + + + + Gets the minimum of the distribution. + + + + + Gets the maximum of the distribution. + + + + + Computes the probability mass (PMF) at k, i.e. P(X = k). + + The location in the domain where we want to evaluate the probability mass function. + the probability mass at location . + + + + Computes the log probability mass (lnPMF) at k, i.e. ln(P(X = k)). + + The location in the domain where we want to evaluate the log probability mass function. + the log probability mass at location . + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + the cumulative distribution at location . + + + + Computes the probability mass (PMF) at k, i.e. P(X = k). + + The location in the domain where we want to evaluate the probability mass function. + The size of the population (N). + The number successes within the population (K, M). + The number of draws without replacement (n). + the probability mass at location . + + + + Computes the log probability mass (lnPMF) at k, i.e. ln(P(X = k)). + + The location in the domain where we want to evaluate the log probability mass function. + The size of the population (N). + The number successes within the population (K, M). + The number of draws without replacement (n). + the log probability mass at location . + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + The size of the population (N). + The number successes within the population (K, M). + The number of draws without replacement (n). + the cumulative distribution at location . + + + + + Generates a sample from the Hypergeometric distribution without doing parameter checking. + + The random number generator to use. + The size of the population (N). + The number successes within the population (K, M). + The n parameter of the distribution. + a random number from the Hypergeometric distribution. + + + + Samples a Hypergeometric distributed random variable. + + The number of successes in n trials. + + + + Fills an array with samples generated from the distribution. + + + + + Samples an array of Hypergeometric distributed random variables. + + a sequence of successes in n trials. + + + + Samples a random variable. + + The random number generator to use. + The size of the population (N). + The number successes within the population (K, M). + The number of draws without replacement (n). + + + + Samples a sequence of this random variable. + + The random number generator to use. + The size of the population (N). + The number successes within the population (K, M). + The number of draws without replacement (n). + + + + Fills an array with samples generated from the distribution. + + The random number generator to use. + The array to fill with the samples. + The size of the population (N). + The number successes within the population (K, M). + The number of draws without replacement (n). + + + + Samples a random variable. + + The size of the population (N). + The number successes within the population (K, M). + The number of draws without replacement (n). + + + + Samples a sequence of this random variable. + + The size of the population (N). + The number successes within the population (K, M). + The number of draws without replacement (n). + + + + Fills an array with samples generated from the distribution. + + The array to fill with the samples. + The size of the population (N). + The number successes within the population (K, M). + The number of draws without replacement (n). + + + + Continuous Univariate Probability Distribution. + + + + + + Gets the mode of the distribution. + + + + + Gets the smallest element in the domain of the distribution which can be represented by a double. + + + + + Gets the largest element in the domain of the distribution which can be represented by a double. + + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The location at which to compute the density. + the density at . + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The location at which to compute the log density. + the log density at . + + + + Draws a random sample from the distribution. + + a sample from the distribution. + + + + Fills an array with samples generated from the distribution. + + + + + Draws a sequence of random samples from the distribution. + + an infinite sequence of samples from the distribution. + + + + Discrete Univariate Probability Distribution. + + + + + + Gets the mode of the distribution. + + + + + Gets the smallest element in the domain of the distribution which can be represented by an integer. + + + + + Gets the largest element in the domain of the distribution which can be represented by an integer. + + + + + Computes the probability mass (PMF) at k, i.e. P(X = k). + + The location in the domain where we want to evaluate the probability mass function. + the probability mass at location . + + + + Computes the log probability mass (lnPMF) at k, i.e. ln(P(X = k)). + + The location in the domain where we want to evaluate the log probability mass function. + the log probability mass at location . + + + + Draws a random sample from the distribution. + + a sample from the distribution. + + + + Fills an array with samples generated from the distribution. + + + + + Draws a sequence of random samples from the distribution. + + an infinite sequence of samples from the distribution. + + + + Probability Distribution. + + + + + + + Gets or sets the random number generator which is used to draw random samples. + + + + + Continuous Univariate Inverse Gamma distribution. + The inverse Gamma distribution is a distribution over the positive real numbers parameterized by + two positive parameters. + Wikipedia - InverseGamma distribution. + + + + + Initializes a new instance of the class. + + The shape (α) of the distribution. Range: α > 0. + The scale (β) of the distribution. Range: β > 0. + + + + Initializes a new instance of the class. + + The shape (α) of the distribution. Range: α > 0. + The scale (β) of the distribution. Range: β > 0. + The random number generator which is used to draw random samples. + + + + A string representation of the distribution. + + a string representation of the distribution. + + + + Tests whether the provided values are valid parameters for this distribution. + + The shape (α) of the distribution. Range: α > 0. + The scale (β) of the distribution. Range: β > 0. + + + + Gets or sets the shape (α) parameter. Range: α > 0. + + + + + Gets or sets The scale (β) parameter. Range: β > 0. + + + + + Gets or sets the random number generator which is used to draw random samples. + + + + + Gets the mean of the distribution. + + + + + Gets the variance of the distribution. + + + + + Gets the standard deviation of the distribution. + + + + + Gets the entropy of the distribution. + + + + + Gets the skewness of the distribution. + + + + + Gets the mode of the distribution. + + + + + Gets the median of the distribution. + + Throws . + + + + Gets the minimum of the distribution. + + + + + Gets the maximum of the distribution. + + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The location at which to compute the density. + the density at . + + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The location at which to compute the log density. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + the cumulative distribution at location . + + + + + Draws a random sample from the distribution. + + A random number from this distribution. + + + + Fills an array with samples generated from the distribution. + + + + + Generates a sequence of samples from the Cauchy distribution. + + a sequence of samples from the distribution. + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The shape (α) of the distribution. Range: α > 0. + The scale (β) of the distribution. Range: β > 0. + The location at which to compute the density. + the density at . + + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The shape (α) of the distribution. Range: α > 0. + The scale (β) of the distribution. Range: β > 0. + The location at which to compute the density. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + The shape (α) of the distribution. Range: α > 0. + The scale (β) of the distribution. Range: β > 0. + the cumulative distribution at location . + + + + + Generates a sample from the distribution. + + The random number generator to use. + The shape (α) of the distribution. Range: α > 0. + The scale (β) of the distribution. Range: β > 0. + a sample from the distribution. + + + + Generates a sequence of samples from the distribution. + + The random number generator to use. + The shape (α) of the distribution. Range: α > 0. + The scale (β) of the distribution. Range: β > 0. + a sequence of samples from the distribution. + + + + Fills an array with samples generated from the distribution. + + The random number generator to use. + The array to fill with the samples. + The shape (α) of the distribution. Range: α > 0. + The scale (β) of the distribution. Range: β > 0. + a sequence of samples from the distribution. + + + + Generates a sample from the distribution. + + The shape (α) of the distribution. Range: α > 0. + The scale (β) of the distribution. Range: β > 0. + a sample from the distribution. + + + + Generates a sequence of samples from the distribution. + + The shape (α) of the distribution. Range: α > 0. + The scale (β) of the distribution. Range: β > 0. + a sequence of samples from the distribution. + + + + Fills an array with samples generated from the distribution. + + The array to fill with the samples. + The shape (α) of the distribution. Range: α > 0. + The scale (β) of the distribution. Range: β > 0. + a sequence of samples from the distribution. + + + + Gets the mean (μ) of the distribution. Range: μ > 0. + + + + + Gets the shape (λ) of the distribution. Range: λ > 0. + + + + + Initializes a new instance of the InverseGaussian class. + + The mean (μ) of the distribution. Range: μ > 0. + The shape (λ) of the distribution. Range: λ > 0. + The random number generator which is used to draw random samples. + + + + A string representation of the distribution. + + a string representation of the distribution. + + + + Tests whether the provided values are valid parameters for this distribution. + + The mean (μ) of the distribution. Range: μ > 0. + The shape (λ) of the distribution. Range: λ > 0. + + + + Gets the random number generator which is used to draw random samples. + + + + + Gets the mean of the Inverse Gaussian distribution. + + + + + Gets the variance of the Inverse Gaussian distribution. + + + + + Gets the standard deviation of the Inverse Gaussian distribution. + + + + + Gets the median of the Inverse Gaussian distribution. + No closed form analytical expression exists, so this value is approximated numerically and can throw an exception. + + + + + Gets the minimum of the Inverse Gaussian distribution. + + + + + Gets the maximum of the Inverse Gaussian distribution. + + + + + Gets the skewness of the Inverse Gaussian distribution. + + + + + Gets the kurtosis of the Inverse Gaussian distribution. + + + + + Gets the mode of the Inverse Gaussian distribution. + + + + + Gets the entropy of the Inverse Gaussian distribution (currently not supported). + + + + + Generates a sample from the inverse Gaussian distribution. + + a sample from the distribution. + + + + Fills an array with samples generated from the distribution. + + The array to fill with the samples. + + + + Generates a sequence of samples from the inverse Gaussian distribution. + + a sequence of samples from the distribution. + + + + Generates a sample from the inverse Gaussian distribution. + + The random number generator to use. + The mean (μ) of the distribution. Range: μ > 0. + The shape (λ) of the distribution. Range: λ > 0. + a sample from the distribution. + + + + Fills an array with samples generated from the distribution. + + The random number generator to use. + The array to fill with the samples. + The mean (μ) of the distribution. Range: μ > 0. + The shape (λ) of the distribution. Range: λ > 0. + + + + Generates a sequence of samples from the Burr distribution. + + The random number generator to use. + The mean (μ) of the distribution. Range: μ > 0. + The shape (λ) of the distribution. Range: λ > 0. + a sequence of samples from the distribution. + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The location at which to compute the density. + the density at . + + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The location at which to compute the log density. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + the cumulative distribution at location . + + + + + Computes the inverse cumulative distribution (CDF) of the distribution at p, i.e. solving for P(X ≤ x) = p. + + The location at which to compute the inverse cumulative distribution function. + the inverse cumulative distribution at location . + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The mean (μ) of the distribution. Range: μ > 0. + The shape (λ) of the distribution. Range: λ > 0. + The location at which to compute the density. + the density at . + + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The mean (μ) of the distribution. Range: μ > 0. + The shape (λ) of the distribution. Range: λ > 0. + The location at which to compute the log density. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The mean (μ) of the distribution. Range: μ > 0. + The shape (λ) of the distribution. Range: λ > 0. + The location at which to compute the cumulative distribution function. + the cumulative distribution at location . + + + + + Computes the inverse cumulative distribution (CDF) of the distribution at p, i.e. solving for P(X ≤ x) = p. + + The mean (μ) of the distribution. Range: μ > 0. + The shape (λ) of the distribution. Range: λ > 0. + The location at which to compute the inverse cumulative distribution function. + the inverse cumulative distribution at location . + + + + + Estimates the Inverse Gaussian parameters from sample data with maximum-likelihood. + + The samples to estimate the distribution parameters from. + The random number generator which is used to draw random samples. Optional, can be null. + An Inverse Gaussian distribution. + + + + Multivariate Inverse Wishart distribution. This distribution is + parameterized by the degrees of freedom nu and the scale matrix S. The inverse Wishart distribution + is the conjugate prior for the covariance matrix of a multivariate normal distribution. + Wikipedia - Inverse-Wishart distribution. + + + + + Caches the Cholesky factorization of the scale matrix. + + + + + Initializes a new instance of the class. + + The degree of freedom (ν) for the inverse Wishart distribution. + The scale matrix (Ψ) for the inverse Wishart distribution. + + + + Initializes a new instance of the class. + + The degree of freedom (ν) for the inverse Wishart distribution. + The scale matrix (Ψ) for the inverse Wishart distribution. + The random number generator which is used to draw random samples. + + + + A string representation of the distribution. + + a string representation of the distribution. + + + + Tests whether the provided values are valid parameters for this distribution. + + The degree of freedom (ν) for the inverse Wishart distribution. + The scale matrix (Ψ) for the inverse Wishart distribution. + + + + Gets or sets the degree of freedom (ν) for the inverse Wishart distribution. + + + + + Gets or sets the scale matrix (Ψ) for the inverse Wishart distribution. + + + + + Gets or sets the random number generator which is used to draw random samples. + + + + + Gets the mean. + + The mean of the distribution. + + + + Gets the mode of the distribution. + + The mode of the distribution. + A. O'Hagan, and J. J. Forster (2004). Kendall's Advanced Theory of Statistics: Bayesian Inference. 2B (2 ed.). Arnold. ISBN 0-340-80752-0. + + + + Gets the variance of the distribution. + + The variance of the distribution. + Kanti V. Mardia, J. T. Kent and J. M. Bibby (1979). Multivariate Analysis. + + + + Evaluates the probability density function for the inverse Wishart distribution. + + The matrix at which to evaluate the density at. + If the argument does not have the same dimensions as the scale matrix. + the density at . + + + + Samples an inverse Wishart distributed random variable by sampling + a Wishart random variable and inverting the matrix. + + a sample from the distribution. + + + + Samples an inverse Wishart distributed random variable by sampling + a Wishart random variable and inverting the matrix. + + The random number generator to use. + The degree of freedom (ν) for the inverse Wishart distribution. + The scale matrix (Ψ) for the inverse Wishart distribution. + a sample from the distribution. + + + + Univariate Probability Distribution. + + + + + + + Gets the mean of the distribution. + + + + + Gets the variance of the distribution. + + + + + Gets the standard deviation of the distribution. + + + + + Gets the entropy of the distribution. + + + + + Gets the skewness of the distribution. + + + + + Gets the median of the distribution. + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + the cumulative distribution at location . + + + + Continuous Univariate Laplace distribution. + The Laplace distribution is a distribution over the real numbers parameterized by a mean and + scale parameter. The PDF is: + p(x) = \frac{1}{2 * scale} \exp{- |x - mean| / scale}. + Wikipedia - Laplace distribution. + + + + + Initializes a new instance of the class (location = 0, scale = 1). + + + + + Initializes a new instance of the class. + + The location (μ) of the distribution. + The scale (b) of the distribution. Range: b > 0. + If is negative. + + + + Initializes a new instance of the class. + + The location (μ) of the distribution. + The scale (b) of the distribution. Range: b > 0. + The random number generator which is used to draw random samples. + If is negative. + + + + A string representation of the distribution. + + a string representation of the distribution. + + + + Tests whether the provided values are valid parameters for this distribution. + + The location (μ) of the distribution. + The scale (b) of the distribution. Range: b > 0. + + + + Gets the location (μ) of the Laplace distribution. + + + + + Gets the scale (b) of the Laplace distribution. Range: b > 0. + + + + + Gets or sets the random number generator which is used to draw random samples. + + + + + Gets the mean of the distribution. + + + + + Gets the variance of the distribution. + + + + + Gets the standard deviation of the distribution. + + + + + Gets the entropy of the distribution. + + + + + Gets the skewness of the distribution. + + + + + Gets the mode of the distribution. + + + + + Gets the median of the distribution. + + + + + Gets the minimum of the distribution. + + + + + Gets the maximum of the distribution. + + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The location at which to compute the density. + the density at . + + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The location at which to compute the log density. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + the cumulative distribution at location . + + + + + Samples a Laplace distributed random variable. + + a sample from the distribution. + + + + Fills an array with samples generated from the distribution. + + + + + Generates a sample from the Laplace distribution. + + a sample from the distribution. + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The location (μ) of the distribution. + The scale (b) of the distribution. Range: b > 0. + The location at which to compute the density. + the density at . + + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The location (μ) of the distribution. + The scale (b) of the distribution. Range: b > 0. + The location at which to compute the density. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + The location (μ) of the distribution. + The scale (b) of the distribution. Range: b > 0. + the cumulative distribution at location . + + + + + Generates a sample from the distribution. + + The random number generator to use. + The location (μ) of the distribution. + The scale (b) of the distribution. Range: b > 0. + a sample from the distribution. + + + + Generates a sequence of samples from the distribution. + + The random number generator to use. + The location (μ) of the distribution. + The scale (b) of the distribution. Range: b > 0. + a sequence of samples from the distribution. + + + + Fills an array with samples generated from the distribution. + + The random number generator to use. + The array to fill with the samples. + The location (μ) of the distribution. + The scale (b) of the distribution. Range: b > 0. + a sequence of samples from the distribution. + + + + Generates a sample from the distribution. + + The location (μ) of the distribution. + The scale (b) of the distribution. Range: b > 0. + a sample from the distribution. + + + + Generates a sequence of samples from the distribution. + + The location (μ) of the distribution. + The scale (b) of the distribution. Range: b > 0. + a sequence of samples from the distribution. + + + + Fills an array with samples generated from the distribution. + + The array to fill with the samples. + The location (μ) of the distribution. + The scale (b) of the distribution. Range: b > 0. + a sequence of samples from the distribution. + + + + Continuous Univariate Logistic distribution. + For details about this distribution, see + Wikipedia - Logistic distribution. + + + + + Initializes a new instance of the Logistic class. This is a logistic distribution with mean 0.0 + and scale 1.0. The distribution will be initialized with the default + random number generator. + + + + + Initializes a new instance of the Logistic class. This is a logistic distribution with mean 0.0 + and scale 1.0. The distribution will be initialized with the default + random number generator. + + The random number generator which is used to draw random samples. + + + + Initializes a new instance of the Logistic class with a particular mean and scale parameter. The + distribution will be initialized with the default random number generator. + + The mean (μ) of the logistic distribution. + The scale (s) of the logistic distribution. Range: s > 0. + + + + Initializes a new instance of the Logistic class with a particular mean and standard deviation. The distribution will + be initialized with the default random number generator. + + The mean (μ) of the logistic distribution. + The scale (s) of the logistic distribution. Range: s > 0. + The random number generator which is used to draw random samples. + + + + Constructs a logistic distribution from a mean and scale parameter. + + The mean (μ) of the logistic distribution. + The scale (s) of the logistic distribution. Range: s > 0. + The random number generator which is used to draw random samples. Optional, can be null. + a logistic distribution. + + + + Constructs a logistic distribution from a mean and standard deviation. + + The mean (μ) of the logistic distribution. + The standard deviation (σ) of the logistic distribution. Range: σ > 0. + The random number generator which is used to draw random samples. Optional, can be null. + a logistic distribution. + + + + Constructs a logistic distribution from a mean and variance. + + The mean (μ) of the logistic distribution. + The variance (σ^2) of the logistic distribution. Range: (σ^2) > 0. + The random number generator which is used to draw random samples. Optional, can be null. + A logistic distribution. + + + + Constructs a logistic distribution from a mean and precision. + + The mean (μ) of the logistic distribution. + The precision of the logistic distribution. Range: precision > 0. + The random number generator which is used to draw random samples. Optional, can be null. + A logistic distribution. + + + + A string representation of the distribution. + + a string representation of the distribution. + + + + Tests whether the provided values are valid parameters for this distribution. + + The mean (μ) of the logistic distribution. + The scale (s) of the logistic distribution. Range: s > 0. + + + + Gets the scale parameter of the Logistic distribution. Range: s > 0. + + + + + Gets the mean (μ) of the logistic distribution. + + + + + Gets the standard deviation (σ) of the logistic distribution. Range: σ > 0. + + + + + Gets the variance of the logistic distribution. + + + + + Gets the precision of the logistic distribution. + + + + + Gets the random number generator which is used to draw random samples. + + + + + Gets the entropy of the logistic distribution. + + + + + Gets the skewness of the logistic distribution. + + + + + Gets the mode of the logistic distribution. + + + + + Gets the median of the logistic distribution. + + + + + Gets the minimum of the logistic distribution. + + + + + Gets the maximum of the logistic distribution. + + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The location at which to compute the density. + the density at . + + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The location at which to compute the log density. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + the cumulative distribution at location . + + + + + Computes the inverse of the cumulative distribution function (InvCDF) for the distribution + at the given probability. This is also known as the quantile or percent point function. + + The location at which to compute the inverse cumulative density. + the inverse cumulative density at . + + + + + Generates a sample from the logistic distribution using the Box-Muller algorithm. + + a sample from the distribution. + + + + Fills an array with samples generated from the distribution. + + + + + Generates a sequence of samples from the logistic distribution using the Box-Muller algorithm. + + a sequence of samples from the distribution. + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The mean (μ) of the logistic distribution. + The scale (s) of the logistic distribution. Range: s > 0. + The location at which to compute the density. + the density at . + + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The mean (μ) of the logistic distribution. + The scale (s) of the logistic distribution. Range: s > 0. + The location at which to compute the density. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + The mean (μ) of the logistic distribution. + The scale (s) of the logistic distribution. Range: s > 0. + the cumulative distribution at location . + + MATLAB: normcdf + + + + Computes the inverse of the cumulative distribution function (InvCDF) for the distribution + at the given probability. This is also known as the quantile or percent point function. + + The location at which to compute the inverse cumulative density. + The mean (μ) of the logistic distribution. + The scale (s) of the logistic distribution. Range: s > 0. + the inverse cumulative density at . + + MATLAB: norminv + + + + Generates a sample from the logistic distribution using the Box-Muller algorithm. + + The random number generator to use. + The mean (μ) of the logistic distribution. + The scale (s) of the logistic distribution. Range: s > 0. + a sample from the distribution. + + + + Generates a sequence of samples from the logistic distribution using the Box-Muller algorithm. + + The random number generator to use. + The mean (μ) of the logistic distribution. + The scale (s) of the logistic distribution. Range: s > 0. + a sequence of samples from the distribution. + + + + Fills an array with samples generated from the distribution. + + The random number generator to use. + The array to fill with the samples. + The mean (μ) of the logistic distribution. + The scale (s) of the logistic distribution. Range: s > 0. + a sequence of samples from the distribution. + + + + Generates a sample from the logistic distribution using the Box-Muller algorithm. + + The mean (μ) of the logistic distribution. + The scale (s) of the logistic distribution. Range: s > 0. + a sample from the distribution. + + + + Generates a sequence of samples from the logistic distribution using the Box-Muller algorithm. + + The mean (μ) of the logistic distribution. + The scale (s) of the logistic distribution. Range: s > 0. + a sequence of samples from the distribution. + + + + Fills an array with samples generated from the distribution. + + The array to fill with the samples. + The mean (μ) of the logistic distribution. + The scale (s) of the logistic distribution. Range: s > 0. + a sequence of samples from the distribution. + + + + Continuous Univariate Log-Normal distribution. + For details about this distribution, see + Wikipedia - Log-Normal distribution. + + + + + Initializes a new instance of the class. + The distribution will be initialized with the default + random number generator. + + The log-scale (μ) of the logarithm of the distribution. + The shape (σ) of the logarithm of the distribution. Range: σ ≥ 0. + + + + Initializes a new instance of the class. + The distribution will be initialized with the default + random number generator. + + The log-scale (μ) of the distribution. + The shape (σ) of the distribution. Range: σ ≥ 0. + The random number generator which is used to draw random samples. + + + + Constructs a log-normal distribution with the desired mu and sigma parameters. + + The log-scale (μ) of the distribution. + The shape (σ) of the distribution. Range: σ ≥ 0. + The random number generator which is used to draw random samples. Optional, can be null. + A log-normal distribution. + + + + Constructs a log-normal distribution with the desired mean and variance. + + The mean of the log-normal distribution. + The variance of the log-normal distribution. + The random number generator which is used to draw random samples. Optional, can be null. + A log-normal distribution. + + + + Estimates the log-normal distribution parameters from sample data with maximum-likelihood. + + The samples to estimate the distribution parameters from. + The random number generator which is used to draw random samples. Optional, can be null. + A log-normal distribution. + MATLAB: lognfit + + + + A string representation of the distribution. + + a string representation of the distribution. + + + + Tests whether the provided values are valid parameters for this distribution. + + The log-scale (μ) of the distribution. + The shape (σ) of the distribution. Range: σ ≥ 0. + + + + Gets the log-scale (μ) (mean of the logarithm) of the distribution. + + + + + Gets the shape (σ) (standard deviation of the logarithm) of the distribution. Range: σ ≥ 0. + + + + + Gets or sets the random number generator which is used to draw random samples. + + + + + Gets the mu of the log-normal distribution. + + + + + Gets the variance of the log-normal distribution. + + + + + Gets the standard deviation of the log-normal distribution. + + + + + Gets the entropy of the log-normal distribution. + + + + + Gets the skewness of the log-normal distribution. + + + + + Gets the mode of the log-normal distribution. + + + + + Gets the median of the log-normal distribution. + + + + + Gets the minimum of the log-normal distribution. + + + + + Gets the maximum of the log-normal distribution. + + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The location at which to compute the density. + the density at . + + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The location at which to compute the log density. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + the cumulative distribution at location . + + + + + Computes the inverse of the cumulative distribution function (InvCDF) for the distribution + at the given probability. This is also known as the quantile or percent point function. + + The location at which to compute the inverse cumulative density. + the inverse cumulative density at . + + + + + Generates a sample from the log-normal distribution using the Box-Muller algorithm. + + a sample from the distribution. + + + + Fills an array with samples generated from the distribution. + + + + + Generates a sequence of samples from the log-normal distribution using the Box-Muller algorithm. + + a sequence of samples from the distribution. + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The location at which to compute the density. + The log-scale (μ) of the distribution. + The shape (σ) of the distribution. Range: σ ≥ 0. + the density at . + + MATLAB: lognpdf + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The location at which to compute the density. + The log-scale (μ) of the distribution. + The shape (σ) of the distribution. Range: σ ≥ 0. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + The log-scale (μ) of the distribution. + The shape (σ) of the distribution. Range: σ ≥ 0. + the cumulative distribution at location . + + MATLAB: logncdf + + + + Computes the inverse of the cumulative distribution function (InvCDF) for the distribution + at the given probability. This is also known as the quantile or percent point function. + + The location at which to compute the inverse cumulative density. + The log-scale (μ) of the distribution. + The shape (σ) of the distribution. Range: σ ≥ 0. + the inverse cumulative density at . + + MATLAB: logninv + + + + Generates a sample from the log-normal distribution using the Box-Muller algorithm. + + The random number generator to use. + The log-scale (μ) of the distribution. + The shape (σ) of the distribution. Range: σ ≥ 0. + a sample from the distribution. + + + + Generates a sequence of samples from the log-normal distribution using the Box-Muller algorithm. + + The random number generator to use. + The log-scale (μ) of the distribution. + The shape (σ) of the distribution. Range: σ ≥ 0. + a sequence of samples from the distribution. + + + + Fills an array with samples generated from the distribution. + + The random number generator to use. + The array to fill with the samples. + The log-scale (μ) of the distribution. + The shape (σ) of the distribution. Range: σ ≥ 0. + a sequence of samples from the distribution. + + + + Generates a sample from the log-normal distribution using the Box-Muller algorithm. + + The log-scale (μ) of the distribution. + The shape (σ) of the distribution. Range: σ ≥ 0. + a sample from the distribution. + + + + Generates a sequence of samples from the log-normal distribution using the Box-Muller algorithm. + + The log-scale (μ) of the distribution. + The shape (σ) of the distribution. Range: σ ≥ 0. + a sequence of samples from the distribution. + + + + Fills an array with samples generated from the distribution. + + The array to fill with the samples. + The log-scale (μ) of the distribution. + The shape (σ) of the distribution. Range: σ ≥ 0. + a sequence of samples from the distribution. + + + + Multivariate Matrix-valued Normal distributions. The distribution + is parameterized by a mean matrix (M), a covariance matrix for the rows (V) and a covariance matrix + for the columns (K). If the dimension of M is d-by-m then V is d-by-d and K is m-by-m. + Wikipedia - MatrixNormal distribution. + + + + + The mean of the matrix normal distribution. + + + + + The covariance matrix for the rows. + + + + + The covariance matrix for the columns. + + + + + Initializes a new instance of the class. + + The mean of the matrix normal. + The covariance matrix for the rows. + The covariance matrix for the columns. + If the dimensions of the mean and two covariance matrices don't match. + + + + Initializes a new instance of the class. + + The mean of the matrix normal. + The covariance matrix for the rows. + The covariance matrix for the columns. + The random number generator which is used to draw random samples. + If the dimensions of the mean and two covariance matrices don't match. + + + + Returns a that represents this instance. + + + A that represents this instance. + + + + + Tests whether the provided values are valid parameters for this distribution. + + The mean of the matrix normal. + The covariance matrix for the rows. + The covariance matrix for the columns. + + + + Gets the mean. (M) + + The mean of the distribution. + + + + Gets the row covariance. (V) + + The row covariance. + + + + Gets the column covariance. (K) + + The column covariance. + + + + Gets or sets the random number generator which is used to draw random samples. + + + + + Evaluates the probability density function for the matrix normal distribution. + + The matrix at which to evaluate the density at. + the density at + If the argument does not have the correct dimensions. + + + + Samples a matrix normal distributed random variable. + + A random number from this distribution. + + + + Samples a matrix normal distributed random variable. + + The random number generator to use. + The mean of the matrix normal. + The covariance matrix for the rows. + The covariance matrix for the columns. + If the dimensions of the mean and two covariance matrices don't match. + a sequence of samples from the distribution. + + + + Samples a vector normal distributed random variable. + + The random number generator to use. + The mean of the vector normal distribution. + The covariance matrix of the vector normal distribution. + a sequence of samples from defined distribution. + + + + Multivariate Multinomial distribution. For details about this distribution, see + Wikipedia - Multinomial distribution. + + + The distribution is parameterized by a vector of ratios: in other words, the parameter + does not have to be normalized and sum to 1. The reason is that some vectors can't be exactly normalized + to sum to 1 in floating point representation. + + + + + Stores the normalized multinomial probabilities. + + + + + The number of trials. + + + + + Initializes a new instance of the Multinomial class. + + An array of nonnegative ratios: this array does not need to be normalized + as this is often impossible using floating point arithmetic. + The number of trials. + If any of the probabilities are negative or do not sum to one. + If is negative. + + + + Initializes a new instance of the Multinomial class. + + An array of nonnegative ratios: this array does not need to be normalized + as this is often impossible using floating point arithmetic. + The number of trials. + The random number generator which is used to draw random samples. + If any of the probabilities are negative or do not sum to one. + If is negative. + + + + Initializes a new instance of the Multinomial class from histogram . The distribution will + not be automatically updated when the histogram changes. + + Histogram instance + The number of trials. + If any of the probabilities are negative or do not sum to one. + If is negative. + + + + A string representation of the distribution. + + a string representation of the distribution. + + + + Tests whether the provided values are valid parameters for this distribution. + + An array of nonnegative ratios: this array does not need to be normalized + as this is often impossible using floating point arithmetic. + The number of trials. + If any of the probabilities are negative returns false, + if the sum of parameters is 0.0, or if the number of trials is negative; otherwise true. + + + + Gets the proportion of ratios. + + + + + Gets the number of trials. + + + + + Gets or sets the random number generator which is used to draw random samples. + + + + + Gets the mean of the distribution. + + + + + Gets the variance of the distribution. + + + + + Gets the skewness of the distribution. + + + + + Computes values of the probability mass function. + + Non-negative integers x1, ..., xk + The probability mass at location . + When is null. + When length of is not equal to event probabilities count. + + + + Computes values of the log probability mass function. + + Non-negative integers x1, ..., xk + The log probability mass at location . + When is null. + When length of is not equal to event probabilities count. + + + + Samples one multinomial distributed random variable. + + the counts for each of the different possible values. + + + + Samples a sequence multinomially distributed random variables. + + a sequence of counts for each of the different possible values. + + + + Samples one multinomial distributed random variable. + + The random number generator to use. + An array of nonnegative ratios: this array does not need to be normalized + as this is often impossible using floating point arithmetic. + The number of trials. + the counts for each of the different possible values. + + + + Samples a multinomially distributed random variable. + + The random number generator to use. + An array of nonnegative ratios: this array does not need to be normalized + as this is often impossible using floating point arithmetic. + The number of variables needed. + a sequence of counts for each of the different possible values. + + + + Discrete Univariate Negative Binomial distribution. + The negative binomial is a distribution over the natural numbers with two parameters r, p. For the special + case that r is an integer one can interpret the distribution as the number of failures before the r'th success + when the probability of success is p. + Wikipedia - NegativeBinomial distribution. + + + + + Initializes a new instance of the class. + + The number of successes (r) required to stop the experiment. Range: r ≥ 0. + The probability (p) of a trial resulting in success. Range: 0 ≤ p ≤ 1. + + + + Initializes a new instance of the class. + + The number of successes (r) required to stop the experiment. Range: r ≥ 0. + The probability (p) of a trial resulting in success. Range: 0 ≤ p ≤ 1. + The random number generator which is used to draw random samples. + + + + Returns a that represents this instance. + + + A that represents this instance. + + + + + Tests whether the provided values are valid parameters for this distribution. + + The number of successes (r) required to stop the experiment. Range: r ≥ 0. + The probability (p) of a trial resulting in success. Range: 0 ≤ p ≤ 1. + + + + Gets the number of successes. Range: r ≥ 0. + + + + + Gets the probability of success. Range: 0 ≤ p ≤ 1. + + + + + Gets or sets the random number generator which is used to draw random samples. + + + + + Gets the mean of the distribution. + + + + + Gets the variance of the distribution. + + + + + Gets the standard deviation of the distribution. + + + + + Gets the entropy of the distribution. + + + + + Gets the skewness of the distribution. + + + + + Gets the mode of the distribution + + + + + Gets the median of the distribution. + + + + + Gets the smallest element in the domain of the distributions which can be represented by an integer. + + + + + Gets the largest element in the domain of the distributions which can be represented by an integer. + + + + + Computes the probability mass (PMF) at k, i.e. P(X = k). + + The location in the domain where we want to evaluate the probability mass function. + the probability mass at location . + + + + Computes the log probability mass (lnPMF) at k, i.e. ln(P(X = k)). + + The location in the domain where we want to evaluate the log probability mass function. + the log probability mass at location . + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + the cumulative distribution at location . + + + + Computes the probability mass (PMF) at k, i.e. P(X = k). + + The location in the domain where we want to evaluate the probability mass function. + The number of successes (r) required to stop the experiment. Range: r ≥ 0. + The probability (p) of a trial resulting in success. Range: 0 ≤ p ≤ 1. + the probability mass at location . + + + + Computes the log probability mass (lnPMF) at k, i.e. ln(P(X = k)). + + The location in the domain where we want to evaluate the log probability mass function. + The number of successes (r) required to stop the experiment. Range: r ≥ 0. + The probability (p) of a trial resulting in success. Range: 0 ≤ p ≤ 1. + the log probability mass at location . + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + The number of successes (r) required to stop the experiment. Range: r ≥ 0. + The probability (p) of a trial resulting in success. Range: 0 ≤ p ≤ 1. + the cumulative distribution at location . + + + + + Samples a negative binomial distributed random variable. + + The random number generator to use. + The number of successes (r) required to stop the experiment. Range: r ≥ 0. + The probability (p) of a trial resulting in success. Range: 0 ≤ p ≤ 1. + a sample from the distribution. + + + + Samples a NegativeBinomial distributed random variable. + + a sample from the distribution. + + + + Fills an array with samples generated from the distribution. + + + + + Samples an array of NegativeBinomial distributed random variables. + + a sequence of samples from the distribution. + + + + Samples a random variable. + + The random number generator to use. + The number of successes (r) required to stop the experiment. Range: r ≥ 0. + The probability (p) of a trial resulting in success. Range: 0 ≤ p ≤ 1. + + + + Samples a sequence of this random variable. + + The random number generator to use. + The number of successes (r) required to stop the experiment. Range: r ≥ 0. + The probability (p) of a trial resulting in success. Range: 0 ≤ p ≤ 1. + + + + Fills an array with samples generated from the distribution. + + The random number generator to use. + The array to fill with the samples. + The number of successes (r) required to stop the experiment. Range: r ≥ 0. + The probability (p) of a trial resulting in success. Range: 0 ≤ p ≤ 1. + + + + Samples a random variable. + + The number of successes (r) required to stop the experiment. Range: r ≥ 0. + The probability (p) of a trial resulting in success. Range: 0 ≤ p ≤ 1. + + + + Samples a sequence of this random variable. + + The number of successes (r) required to stop the experiment. Range: r ≥ 0. + The probability (p) of a trial resulting in success. Range: 0 ≤ p ≤ 1. + + + + Fills an array with samples generated from the distribution. + + The array to fill with the samples. + The number of successes (r) required to stop the experiment. Range: r ≥ 0. + The probability (p) of a trial resulting in success. Range: 0 ≤ p ≤ 1. + + + + Continuous Univariate Normal distribution, also known as Gaussian distribution. + For details about this distribution, see + Wikipedia - Normal distribution. + + + + + Initializes a new instance of the Normal class. This is a normal distribution with mean 0.0 + and standard deviation 1.0. The distribution will + be initialized with the default random number generator. + + + + + Initializes a new instance of the Normal class. This is a normal distribution with mean 0.0 + and standard deviation 1.0. The distribution will + be initialized with the default random number generator. + + The random number generator which is used to draw random samples. + + + + Initializes a new instance of the Normal class with a particular mean and standard deviation. The distribution will + be initialized with the default random number generator. + + The mean (μ) of the normal distribution. + The standard deviation (σ) of the normal distribution. Range: σ ≥ 0. + + + + Initializes a new instance of the Normal class with a particular mean and standard deviation. The distribution will + be initialized with the default random number generator. + + The mean (μ) of the normal distribution. + The standard deviation (σ) of the normal distribution. Range: σ ≥ 0. + The random number generator which is used to draw random samples. + + + + Constructs a normal distribution from a mean and standard deviation. + + The mean (μ) of the normal distribution. + The standard deviation (σ) of the normal distribution. Range: σ ≥ 0. + The random number generator which is used to draw random samples. Optional, can be null. + a normal distribution. + + + + Constructs a normal distribution from a mean and variance. + + The mean (μ) of the normal distribution. + The variance (σ^2) of the normal distribution. + The random number generator which is used to draw random samples. Optional, can be null. + A normal distribution. + + + + Constructs a normal distribution from a mean and precision. + + The mean (μ) of the normal distribution. + The precision of the normal distribution. + The random number generator which is used to draw random samples. Optional, can be null. + A normal distribution. + + + + Estimates the normal distribution parameters from sample data with maximum-likelihood. + + The samples to estimate the distribution parameters from. + The random number generator which is used to draw random samples. Optional, can be null. + A normal distribution. + MATLAB: normfit + + + + A string representation of the distribution. + + a string representation of the distribution. + + + + Tests whether the provided values are valid parameters for this distribution. + + The mean (μ) of the normal distribution. + The standard deviation (σ) of the normal distribution. Range: σ ≥ 0. + + + + Gets the mean (μ) of the normal distribution. + + + + + Gets the standard deviation (σ) of the normal distribution. Range: σ ≥ 0. + + + + + Gets the variance of the normal distribution. + + + + + Gets the precision of the normal distribution. + + + + + Gets the random number generator which is used to draw random samples. + + + + + Gets the entropy of the normal distribution. + + + + + Gets the skewness of the normal distribution. + + + + + Gets the mode of the normal distribution. + + + + + Gets the median of the normal distribution. + + + + + Gets the minimum of the normal distribution. + + + + + Gets the maximum of the normal distribution. + + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The location at which to compute the density. + the density at . + + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The location at which to compute the log density. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + the cumulative distribution at location . + + + + + Computes the inverse of the cumulative distribution function (InvCDF) for the distribution + at the given probability. This is also known as the quantile or percent point function. + + The location at which to compute the inverse cumulative density. + the inverse cumulative density at . + + + + + Generates a sample from the normal distribution using the Box-Muller algorithm. + + a sample from the distribution. + + + + Fills an array with samples generated from the distribution. + + + + + Generates a sequence of samples from the normal distribution using the Box-Muller algorithm. + + a sequence of samples from the distribution. + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The mean (μ) of the normal distribution. + The standard deviation (σ) of the normal distribution. Range: σ ≥ 0. + The location at which to compute the density. + the density at . + + MATLAB: normpdf + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The mean (μ) of the normal distribution. + The standard deviation (σ) of the normal distribution. Range: σ ≥ 0. + The location at which to compute the density. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + The mean (μ) of the normal distribution. + The standard deviation (σ) of the normal distribution. Range: σ ≥ 0. + the cumulative distribution at location . + + MATLAB: normcdf + + + + Computes the inverse of the cumulative distribution function (InvCDF) for the distribution + at the given probability. This is also known as the quantile or percent point function. + + The location at which to compute the inverse cumulative density. + The mean (μ) of the normal distribution. + The standard deviation (σ) of the normal distribution. Range: σ ≥ 0. + the inverse cumulative density at . + + MATLAB: norminv + + + + Generates a sample from the normal distribution using the Box-Muller algorithm. + + The random number generator to use. + The mean (μ) of the normal distribution. + The standard deviation (σ) of the normal distribution. Range: σ ≥ 0. + a sample from the distribution. + + + + Generates a sequence of samples from the normal distribution using the Box-Muller algorithm. + + The random number generator to use. + The mean (μ) of the normal distribution. + The standard deviation (σ) of the normal distribution. Range: σ ≥ 0. + a sequence of samples from the distribution. + + + + Fills an array with samples generated from the distribution. + + The random number generator to use. + The array to fill with the samples. + The mean (μ) of the normal distribution. + The standard deviation (σ) of the normal distribution. Range: σ ≥ 0. + a sequence of samples from the distribution. + + + + Generates a sample from the normal distribution using the Box-Muller algorithm. + + The mean (μ) of the normal distribution. + The standard deviation (σ) of the normal distribution. Range: σ ≥ 0. + a sample from the distribution. + + + + Generates a sequence of samples from the normal distribution using the Box-Muller algorithm. + + The mean (μ) of the normal distribution. + The standard deviation (σ) of the normal distribution. Range: σ ≥ 0. + a sequence of samples from the distribution. + + + + Fills an array with samples generated from the distribution. + + The array to fill with the samples. + The mean (μ) of the normal distribution. + The standard deviation (σ) of the normal distribution. Range: σ ≥ 0. + a sequence of samples from the distribution. + + + + This structure represents the type over which the distribution + is defined. + + + + + Initializes a new instance of the struct. + + The mean of the pair. + The precision of the pair. + + + + Gets or sets the mean of the pair. + + + + + Gets or sets the precision of the pair. + + + + + Multivariate Normal-Gamma Distribution. + The distribution is the conjugate prior distribution for the + distribution. It specifies a prior over the mean and precision of the distribution. + It is parameterized by four numbers: the mean location, the mean scale, the precision shape and the + precision inverse scale. + The distribution NG(mu, tau | mloc,mscale,psscale,pinvscale) = Normal(mu | mloc, 1/(mscale*tau)) * Gamma(tau | psscale,pinvscale). + The following degenerate cases are special: when the precision is known, + the precision shape will encode the value of the precision while the precision inverse scale is positive + infinity. When the mean is known, the mean location will encode the value of the mean while the scale + will be positive infinity. A completely degenerate NormalGamma distribution with known mean and precision is possible as well. + Wikipedia - Normal-Gamma distribution. + + + + + Initializes a new instance of the class. + + The location of the mean. + The scale of the mean. + The shape of the precision. + The inverse scale of the precision. + + + + Initializes a new instance of the class. + + The location of the mean. + The scale of the mean. + The shape of the precision. + The inverse scale of the precision. + The random number generator which is used to draw random samples. + + + + A string representation of the distribution. + + a string representation of the distribution. + + + + Tests whether the provided values are valid parameters for this distribution. + + The location of the mean. + The scale of the mean. + The shape of the precision. + The inverse scale of the precision. + + + + Gets the location of the mean. + + + + + Gets the scale of the mean. + + + + + Gets the shape of the precision. + + + + + Gets the inverse scale of the precision. + + + + + Gets or sets the random number generator which is used to draw random samples. + + + + + Returns the marginal distribution for the mean of the NormalGamma distribution. + + the marginal distribution for the mean of the NormalGamma distribution. + + + + Returns the marginal distribution for the precision of the distribution. + + The marginal distribution for the precision of the distribution/ + + + + Gets the mean of the distribution. + + The mean of the distribution. + + + + Gets the variance of the distribution. + + The mean of the distribution. + + + + Evaluates the probability density function for a NormalGamma distribution. + + The mean/precision pair of the distribution + Density value + + + + Evaluates the probability density function for a NormalGamma distribution. + + The mean of the distribution + The precision of the distribution + Density value + + + + Evaluates the log probability density function for a NormalGamma distribution. + + The mean/precision pair of the distribution + The log of the density value + + + + Evaluates the log probability density function for a NormalGamma distribution. + + The mean of the distribution + The precision of the distribution + The log of the density value + + + + Generates a sample from the NormalGamma distribution. + + a sample from the distribution. + + + + Generates a sequence of samples from the NormalGamma distribution + + a sequence of samples from the distribution. + + + + Generates a sample from the NormalGamma distribution. + + The random number generator to use. + The location of the mean. + The scale of the mean. + The shape of the precision. + The inverse scale of the precision. + a sample from the distribution. + + + + Generates a sequence of samples from the NormalGamma distribution + + The random number generator to use. + The location of the mean. + The scale of the mean. + The shape of the precision. + The inverse scale of the precision. + a sequence of samples from the distribution. + + + + Continuous Univariate Pareto distribution. + The Pareto distribution is a power law probability distribution that coincides with social, + scientific, geophysical, actuarial, and many other types of observable phenomena. + For details about this distribution, see + Wikipedia - Pareto distribution. + + + + + Initializes a new instance of the class. + + The scale (xm) of the distribution. Range: xm > 0. + The shape (α) of the distribution. Range: α > 0. + If or are negative. + + + + Initializes a new instance of the class. + + The scale (xm) of the distribution. Range: xm > 0. + The shape (α) of the distribution. Range: α > 0. + The random number generator which is used to draw random samples. + If or are negative. + + + + A string representation of the distribution. + + a string representation of the distribution. + + + + Tests whether the provided values are valid parameters for this distribution. + + The scale (xm) of the distribution. Range: xm > 0. + The shape (α) of the distribution. Range: α > 0. + + + + Gets the scale (xm) of the distribution. Range: xm > 0. + + + + + Gets the shape (α) of the distribution. Range: α > 0. + + + + + Gets or sets the random number generator which is used to draw random samples. + + + + + Gets the mean of the distribution. + + + + + Gets the variance of the distribution. + + + + + Gets the standard deviation of the distribution. + + + + + Gets the entropy of the distribution. + + + + + Gets the skewness of the distribution. + + + + + Gets the mode of the distribution. + + + + + Gets the median of the distribution. + + + + + Gets the minimum of the distribution. + + + + + Gets the maximum of the distribution. + + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The location at which to compute the density. + the density at . + + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The location at which to compute the log density. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + the cumulative distribution at location . + + + + + Computes the inverse of the cumulative distribution function (InvCDF) for the distribution + at the given probability. This is also known as the quantile or percent point function. + + The location at which to compute the inverse cumulative density. + the inverse cumulative density at . + + + + + Draws a random sample from the distribution. + + A random number from this distribution. + + + + Fills an array with samples generated from the distribution. + + + + + Generates a sequence of samples from the Pareto distribution. + + a sequence of samples from the distribution. + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The scale (xm) of the distribution. Range: xm > 0. + The shape (α) of the distribution. Range: α > 0. + The location at which to compute the density. + the density at . + + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The scale (xm) of the distribution. Range: xm > 0. + The shape (α) of the distribution. Range: α > 0. + The location at which to compute the density. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + The scale (xm) of the distribution. Range: xm > 0. + The shape (α) of the distribution. Range: α > 0. + the cumulative distribution at location . + + + + + Computes the inverse of the cumulative distribution function (InvCDF) for the distribution + at the given probability. This is also known as the quantile or percent point function. + + The location at which to compute the inverse cumulative density. + The scale (xm) of the distribution. Range: xm > 0. + The shape (α) of the distribution. Range: α > 0. + the inverse cumulative density at . + + + + + Generates a sample from the distribution. + + The random number generator to use. + The scale (xm) of the distribution. Range: xm > 0. + The shape (α) of the distribution. Range: α > 0. + a sample from the distribution. + + + + Generates a sequence of samples from the distribution. + + The random number generator to use. + The scale (xm) of the distribution. Range: xm > 0. + The shape (α) of the distribution. Range: α > 0. + a sequence of samples from the distribution. + + + + Fills an array with samples generated from the distribution. + + The random number generator to use. + The array to fill with the samples. + The scale (xm) of the distribution. Range: xm > 0. + The shape (α) of the distribution. Range: α > 0. + a sequence of samples from the distribution. + + + + Generates a sample from the distribution. + + The scale (xm) of the distribution. Range: xm > 0. + The shape (α) of the distribution. Range: α > 0. + a sample from the distribution. + + + + Generates a sequence of samples from the distribution. + + The scale (xm) of the distribution. Range: xm > 0. + The shape (α) of the distribution. Range: α > 0. + a sequence of samples from the distribution. + + + + Fills an array with samples generated from the distribution. + + The array to fill with the samples. + The scale (xm) of the distribution. Range: xm > 0. + The shape (α) of the distribution. Range: α > 0. + a sequence of samples from the distribution. + + + + Discrete Univariate Poisson distribution. + + + Distribution is described at Wikipedia - Poisson distribution. + Knuth's method is used to generate Poisson distributed random variables. + f(x) = exp(-λ)*λ^x/x!; + + + + + Initializes a new instance of the class. + + The lambda (λ) parameter of the Poisson distribution. Range: λ > 0. + If is equal or less then 0.0. + + + + Initializes a new instance of the class. + + The lambda (λ) parameter of the Poisson distribution. Range: λ > 0. + The random number generator which is used to draw random samples. + If is equal or less then 0.0. + + + + Returns a that represents this instance. + + + A that represents this instance. + + + + + Tests whether the provided values are valid parameters for this distribution. + + The lambda (λ) parameter of the Poisson distribution. Range: λ > 0. + + + + Gets the Poisson distribution parameter λ. Range: λ > 0. + + + + + Gets the random number generator which is used to draw random samples. + + + + + Gets the mean of the distribution. + + + + + Gets the variance of the distribution. + + + + + Gets the standard deviation of the distribution. + + + + + Gets the entropy of the distribution. + + Approximation, see Wikipedia Poisson distribution + + + + Gets the skewness of the distribution. + + + + + Gets the smallest element in the domain of the distributions which can be represented by an integer. + + + + + Gets the largest element in the domain of the distributions which can be represented by an integer. + + + + + Gets the mode of the distribution. + + + + + Gets the median of the distribution. + + Approximation, see Wikipedia Poisson distribution + + + + Computes the probability mass (PMF) at k, i.e. P(X = k). + + The location in the domain where we want to evaluate the probability mass function. + the probability mass at location . + + + + Computes the log probability mass (lnPMF) at k, i.e. ln(P(X = k)). + + The location in the domain where we want to evaluate the log probability mass function. + the log probability mass at location . + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + the cumulative distribution at location . + + + + Computes the probability mass (PMF) at k, i.e. P(X = k). + + The location in the domain where we want to evaluate the probability mass function. + The lambda (λ) parameter of the Poisson distribution. Range: λ > 0. + the probability mass at location . + + + + Computes the log probability mass (lnPMF) at k, i.e. ln(P(X = k)). + + The location in the domain where we want to evaluate the log probability mass function. + The lambda (λ) parameter of the Poisson distribution. Range: λ > 0. + the log probability mass at location . + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + The lambda (λ) parameter of the Poisson distribution. Range: λ > 0. + the cumulative distribution at location . + + + + + Generates one sample from the Poisson distribution. + + The random source to use. + The lambda (λ) parameter of the Poisson distribution. Range: λ > 0. + A random sample from the Poisson distribution. + + + + Generates one sample from the Poisson distribution by Knuth's method. + + The random source to use. + The lambda (λ) parameter of the Poisson distribution. Range: λ > 0. + A random sample from the Poisson distribution. + + + + Generates one sample from the Poisson distribution by "Rejection method PA". + + The random source to use. + The lambda (λ) parameter of the Poisson distribution. Range: λ > 0. + A random sample from the Poisson distribution. + "Rejection method PA" from "The Computer Generation of Poisson Random Variables" by A. C. Atkinson, + Journal of the Royal Statistical Society Series C (Applied Statistics) Vol. 28, No. 1. (1979) + The article is on pages 29-35. The algorithm given here is on page 32. + + + + Samples a Poisson distributed random variable. + + A sample from the Poisson distribution. + + + + Fills an array with samples generated from the distribution. + + + + + Samples an array of Poisson distributed random variables. + + a sequence of successes in N trials. + + + + Samples a Poisson distributed random variable. + + The random number generator to use. + The lambda (λ) parameter of the Poisson distribution. Range: λ > 0. + A sample from the Poisson distribution. + + + + Samples a sequence of Poisson distributed random variables. + + The random number generator to use. + The lambda (λ) parameter of the Poisson distribution. Range: λ > 0. + a sequence of samples from the distribution. + + + + Fills an array with samples generated from the distribution. + + The random number generator to use. + The array to fill with the samples. + The lambda (λ) parameter of the Poisson distribution. Range: λ > 0. + a sequence of samples from the distribution. + + + + Samples a Poisson distributed random variable. + + The lambda (λ) parameter of the Poisson distribution. Range: λ > 0. + A sample from the Poisson distribution. + + + + Samples a sequence of Poisson distributed random variables. + + The lambda (λ) parameter of the Poisson distribution. Range: λ > 0. + a sequence of samples from the distribution. + + + + Fills an array with samples generated from the distribution. + + The array to fill with the samples. + The lambda (λ) parameter of the Poisson distribution. Range: λ > 0. + a sequence of samples from the distribution. + + + + Continuous Univariate Rayleigh distribution. + The Rayleigh distribution (pronounced /ˈreɪli/) is a continuous probability distribution. As an + example of how it arises, the wind speed will have a Rayleigh distribution if the components of + the two-dimensional wind velocity vector are uncorrelated and normally distributed with equal variance. + For details about this distribution, see + Wikipedia - Rayleigh distribution. + + + + + Initializes a new instance of the class. + + The scale (σ) of the distribution. Range: σ > 0. + If is negative. + + + + Initializes a new instance of the class. + + The scale (σ) of the distribution. Range: σ > 0. + The random number generator which is used to draw random samples. + If is negative. + + + + A string representation of the distribution. + + a string representation of the distribution. + + + + Tests whether the provided values are valid parameters for this distribution. + + The scale (σ) of the distribution. Range: σ > 0. + + + + Gets the scale (σ) of the distribution. Range: σ > 0. + + + + + Gets or sets the random number generator which is used to draw random samples. + + + + + Gets the mean of the distribution. + + + + + Gets the variance of the distribution. + + + + + Gets the standard deviation of the distribution. + + + + + Gets the entropy of the distribution. + + + + + Gets the skewness of the distribution. + + + + + Gets the mode of the distribution. + + + + + Gets the median of the distribution. + + + + + Gets the minimum of the distribution. + + + + + Gets the maximum of the distribution. + + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The location at which to compute the density. + the density at . + + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The location at which to compute the log density. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + the cumulative distribution at location . + + + + + Computes the inverse of the cumulative distribution function (InvCDF) for the distribution + at the given probability. This is also known as the quantile or percent point function. + + The location at which to compute the inverse cumulative density. + the inverse cumulative density at . + + + + + Draws a random sample from the distribution. + + A random number from this distribution. + + + + Fills an array with samples generated from the distribution. + + + + + Generates a sequence of samples from the Rayleigh distribution. + + a sequence of samples from the distribution. + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The scale (σ) of the distribution. Range: σ > 0. + The location at which to compute the density. + the density at . + + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The scale (σ) of the distribution. Range: σ > 0. + The location at which to compute the density. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + The scale (σ) of the distribution. Range: σ > 0. + the cumulative distribution at location . + + + + + Computes the inverse of the cumulative distribution function (InvCDF) for the distribution + at the given probability. This is also known as the quantile or percent point function. + + The location at which to compute the inverse cumulative density. + The scale (σ) of the distribution. Range: σ > 0. + the inverse cumulative density at . + + + + + Generates a sample from the distribution. + + The random number generator to use. + The scale (σ) of the distribution. Range: σ > 0. + a sample from the distribution. + + + + Generates a sequence of samples from the distribution. + + The random number generator to use. + The scale (σ) of the distribution. Range: σ > 0. + a sequence of samples from the distribution. + + + + Fills an array with samples generated from the distribution. + + The random number generator to use. + The array to fill with the samples. + The scale (σ) of the distribution. Range: σ > 0. + a sequence of samples from the distribution. + + + + Generates a sample from the distribution. + + The scale (σ) of the distribution. Range: σ > 0. + a sample from the distribution. + + + + Generates a sequence of samples from the distribution. + + The scale (σ) of the distribution. Range: σ > 0. + a sequence of samples from the distribution. + + + + Fills an array with samples generated from the distribution. + + The array to fill with the samples. + The scale (σ) of the distribution. Range: σ > 0. + a sequence of samples from the distribution. + + + + Continuous Univariate Skewed Generalized Error Distribution (SGED). + Implements the univariate Skewed Generalized Error Distribution. For details about this + distribution, see + + Wikipedia - Generalized Error Distribution. + It includes Laplace, Normal and Student-t distributions. + This is the distribution with q=Inf. + + This implementation is based on the R package dsgt and corresponding viginette, see + https://cran.r-project.org/web/packages/sgt/vignettes/sgt.pdf. Compared to that + implementation, the options for mean adjustment and variance adjustment are always true. + The location (μ) is the mean of the distribution. + The scale (σ) squared is the variance of the distribution. + + The distribution will use the by + default. Users can get/set the random number generator by using the + property. + The statistics classes will check all the incoming parameters + whether they are in the allowed range. + + + + Initializes a new instance of the SkewedGeneralizedError class. This is a generalized error distribution + with location=0.0, scale=1.0, skew=0.0 and p=2.0 (a standard normal distribution). + + + + + Initializes a new instance of the SkewedGeneralizedT class with a particular location, scale, skew + and kurtosis parameters. Different parameterizations result in different distributions. + + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + The skew, 1 > λ > -1 + Parameter that controls kurtosis. Range: p > 0 + + + + Gets or sets the random number generator which is used to draw random samples. + + + + + A string representation of the distribution. + + a string representation of the distribution. + + + + Tests whether the provided values are valid parameters for this distribution. + + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + The skew, 1 > λ > -1 + Parameter that controls kurtosis. Range: p > 0 + + + + Gets the location (μ) of the Skewed Generalized t-distribution. + + + + + Gets the scale (σ) of the Skewed Generalized t-distribution. Range: σ > 0. + + + + + Gets the skew (λ) of the Skewed Generalized t-distribution. Range: 1 > λ > -1. + + + + + Gets the parameter that controls the kurtosis of the distribution. Range: p > 0. + + + + + Generates a sample from the Skew Generalized Error distribution. + + The random number generator to use. + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + The skew, 1 > λ > -1 + Parameter that controls kurtosis. Range: p > 0 + a sample from the distribution. + + + + Generates a sequence of samples from the Skew Generalized Error distribution using inverse transform. + + The random number generator to use. + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + The skew, 1 > λ > -1 + Parameter that controls kurtosis. Range: p > 0 + a sequence of samples from the distribution. + + + + Fills an array with samples from the Skew Generalized Error distribution using inverse transform. + + The random number generator to use. + The array to fill with the samples. + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + The skew, 1 > λ > -1 + Parameter that controls kurtosis. Range: p > 0 + a sequence of samples from the distribution. + + + + Generates a sample from the Skew Generalized Error distribution. + + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + The skew, 1 > λ > -1 + Parameter that controls kurtosis. Range: p > 0 + a sample from the distribution. + + + + Generates a sequence of samples from the Skew Generalized Error distribution using inverse transform. + + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + The skew, 1 > λ > -1 + Parameter that controls kurtosis. Range: p > 0 + a sequence of samples from the distribution. + + + + Fills an array with samples from the Skew Generalized Error distribution using inverse transform. + + The array to fill with the samples. + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + The skew, 1 > λ > -1 + Parameter that controls kurtosis. Range: p > 0 + a sequence of samples from the distribution. + + + + Continuous Univariate Skewed Generalized T-distribution. + Implements the univariate Skewed Generalized t-distribution. For details about this + distribution, see + + Wikipedia - Skewed generalized t-distribution. + The skewed generalized t-distribution contains many different distributions within it + as special cases based on the parameterization chosen. + + This implementation is based on the R package dsgt and corresponding viginette, see + https://cran.r-project.org/web/packages/sgt/vignettes/sgt.pdf. Compared to that + implementation, the options for mean adjustment and variance adjustment are always true. + The location (μ) is the mean of the distribution. + The scale (σ) squared is the variance of the distribution. + + The distribution will use the by + default. Users can get/set the random number generator by using the + property. + The statistics classes will check all the incoming parameters + whether they are in the allowed range. + + + + Initializes a new instance of the SkewedGeneralizedT class. This is a skewed generalized t-distribution + with location=0.0, scale=1.0, skew=0.0, p=2.0 and q=Inf (a standard normal distribution). + + + + + Initializes a new instance of the SkewedGeneralizedT class with a particular location, scale, skew + and kurtosis parameters. Different parameterizations result in different distributions. + + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + The skew, 1 > λ > -1 + First parameter that controls kurtosis. Range: p > 0 + Second parameter that controls kurtosis. Range: q > 0 + + + + Given a parameter set, returns the distribution that matches this parameterization. + + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + The skew, 1 > λ > -1 + First parameter that controls kurtosis. Range: p > 0 + Second parameter that controls kurtosis. Range: q > 0 + Null if no known distribution matches the parameterization, else the distribution. + + + + Gets or sets the random number generator which is used to draw random samples. + + + + + A string representation of the distribution. + + a string representation of the distribution. + + + + Tests whether the provided values are valid parameters for this distribution. + + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + The skew, 1 > λ > -1 + First parameter that controls kurtosis. Range: p > 0 + Second parameter that controls kurtosis. Range: q > 0 + + + + Gets the location (μ) of the Skewed Generalized t-distribution. + + + + + Gets the scale (σ) of the Skewed Generalized t-distribution. Range: σ > 0. + + + + + Gets the skew (λ) of the Skewed Generalized t-distribution. Range: 1 > λ > -1. + + + + + Gets the first parameter that controls the kurtosis of the distribution. Range: p > 0. + + + + + Gets the second parameter that controls the kurtosis of the distribution. Range: q > 0. + + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + The skew, 1 > λ > -1 + First parameter that controls kurtosis. Range: p > 0 + Second parameter that controls kurtosis. Range: q > 0 + The location at which to compute the density. + the density at . + + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + The skew, 1 > λ > -1 + First parameter that controls kurtosis. Range: p > 0 + Second parameter that controls kurtosis. Range: q > 0 + The location at which to compute the density. + the density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + The skew, 1 > λ > -1 + First parameter that controls kurtosis. Range: p > 0 + Second parameter that controls kurtosis. Range: q > 0 + the cumulative distribution at location . + + + + + Computes the inverse of the cumulative distribution function (InvCDF) for the distribution + at the given probability. This is also known as the quantile or percent point function. + + The location at which to compute the inverse cumulative density. + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + The skew, 1 > λ > -1 + First parameter that controls kurtosis. Range: p > 0 + Second parameter that controls kurtosis. Range: q > 0 + the inverse cumulative density at . + + + + + Computes the inverse of the cumulative distribution function (InvCDF) for the distribution + at the given probability. This is also known as the quantile or percent point function. + + The location at which to compute the inverse cumulative density. + the inverse cumulative density at . + + + + + Generates a sample from the Skew Generalized t-distribution. + + The random number generator to use. + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + The skew, 1 > λ > -1 + First parameter that controls kurtosis. Range: p > 0 + Second parameter that controls kurtosis. Range: q > 0 + a sample from the distribution. + + + + Generates a sequence of samples from the Skew Generalized t-distribution using inverse transform. + + The random number generator to use. + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + The skew, 1 > λ > -1 + First parameter that controls kurtosis. Range: p > 0 + Second parameter that controls kurtosis. Range: q > 0 + a sequence of samples from the distribution. + + + + Fills an array with samples from the Skew Generalized t-distribution using inverse transform. + + The random number generator to use. + The array to fill with the samples. + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + The skew, 1 > λ > -1 + First parameter that controls kurtosis. Range: p > 0 + Second parameter that controls kurtosis. Range: q > 0 + a sequence of samples from the distribution. + + + + Generates a sample from the Skew Generalized t-distribution. + + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + The skew, 1 > λ > -1 + First parameter that controls kurtosis. Range: p > 0 + Second parameter that controls kurtosis. Range: q > 0 + a sample from the distribution. + + + + Generates a sequence of samples from the Skew Generalized t-distribution using inverse transform. + + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + The skew, 1 > λ > -1 + First parameter that controls kurtosis. Range: p > 0 + Second parameter that controls kurtosis. Range: q > 0 + a sequence of samples from the distribution. + + + + Fills an array with samples from the Skew Generalized t-distribution using inverse transform. + + The array to fill with the samples. + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + The skew, 1 > λ > -1 + First parameter that controls kurtosis. Range: p > 0 + Second parameter that controls kurtosis. Range: q > 0 + a sequence of samples from the distribution. + + + + Continuous Univariate Stable distribution. + A random variable is said to be stable (or to have a stable distribution) if it has + the property that a linear combination of two independent copies of the variable has + the same distribution, up to location and scale parameters. + For details about this distribution, see + Wikipedia - Stable distribution. + + + + + Initializes a new instance of the class. + + The stability (α) of the distribution. Range: 2 ≥ α > 0. + The skewness (β) of the distribution. Range: 1 ≥ β ≥ -1. + The scale (c) of the distribution. Range: c > 0. + The location (μ) of the distribution. + + + + Initializes a new instance of the class. + + The stability (α) of the distribution. Range: 2 ≥ α > 0. + The skewness (β) of the distribution. Range: 1 ≥ β ≥ -1. + The scale (c) of the distribution. Range: c > 0. + The location (μ) of the distribution. + The random number generator which is used to draw random samples. + + + + A string representation of the distribution. + + a string representation of the distribution. + + + + Tests whether the provided values are valid parameters for this distribution. + + The stability (α) of the distribution. Range: 2 ≥ α > 0. + The skewness (β) of the distribution. Range: 1 ≥ β ≥ -1. + The scale (c) of the distribution. Range: c > 0. + The location (μ) of the distribution. + + + + Gets the stability (α) of the distribution. Range: 2 ≥ α > 0. + + + + + Gets The skewness (β) of the distribution. Range: 1 ≥ β ≥ -1. + + + + + Gets the scale (c) of the distribution. Range: c > 0. + + + + + Gets the location (μ) of the distribution. + + + + + Gets or sets the random number generator which is used to draw random samples. + + + + + Gets the mean of the distribution. + + + + + Gets the variance of the distribution. + + + + + Gets the standard deviation of the distribution. + + + + + Gets he entropy of the distribution. + + Always throws a not supported exception. + + + + Gets the skewness of the distribution. + + Throws a not supported exception of Alpha != 2. + + + + Gets the mode of the distribution. + + Throws a not supported exception if Beta != 0. + + + + Gets the median of the distribution. + + Throws a not supported exception if Beta != 0. + + + + Gets the minimum of the distribution. + + + + + Gets the maximum of the distribution. + + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The location at which to compute the density. + the density at . + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The location at which to compute the log density. + the log density at . + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + the cumulative distribution at location . + Throws a not supported exception if Alpha != 2, (Alpha != 1 and Beta !=0), or (Alpha != 0.5 and Beta != 1) + + + + Samples the distribution. + + The random number generator to use. + The stability (α) of the distribution. Range: 2 ≥ α > 0. + The skewness (β) of the distribution. Range: 1 ≥ β ≥ -1. + The scale (c) of the distribution. Range: c > 0. + The location (μ) of the distribution. + a random number from the distribution. + + + + Draws a random sample from the distribution. + + A random number from this distribution. + + + + Fills an array with samples generated from the distribution. + + + + + Generates a sequence of samples from the Stable distribution. + + a sequence of samples from the distribution. + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The stability (α) of the distribution. Range: 2 ≥ α > 0. + The skewness (β) of the distribution. Range: 1 ≥ β ≥ -1. + The scale (c) of the distribution. Range: c > 0. + The location (μ) of the distribution. + The location at which to compute the density. + the density at . + + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The stability (α) of the distribution. Range: 2 ≥ α > 0. + The skewness (β) of the distribution. Range: 1 ≥ β ≥ -1. + The scale (c) of the distribution. Range: c > 0. + The location (μ) of the distribution. + The location at which to compute the density. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + The stability (α) of the distribution. Range: 2 ≥ α > 0. + The skewness (β) of the distribution. Range: 1 ≥ β ≥ -1. + The scale (c) of the distribution. Range: c > 0. + The location (μ) of the distribution. + the cumulative distribution at location . + + + + + Generates a sample from the distribution. + + The random number generator to use. + The stability (α) of the distribution. Range: 2 ≥ α > 0. + The skewness (β) of the distribution. Range: 1 ≥ β ≥ -1. + The scale (c) of the distribution. Range: c > 0. + The location (μ) of the distribution. + a sample from the distribution. + + + + Generates a sequence of samples from the distribution. + + The random number generator to use. + The stability (α) of the distribution. Range: 2 ≥ α > 0. + The skewness (β) of the distribution. Range: 1 ≥ β ≥ -1. + The scale (c) of the distribution. Range: c > 0. + The location (μ) of the distribution. + a sequence of samples from the distribution. + + + + Fills an array with samples generated from the distribution. + + The random number generator to use. + The array to fill with the samples. + The stability (α) of the distribution. Range: 2 ≥ α > 0. + The skewness (β) of the distribution. Range: 1 ≥ β ≥ -1. + The scale (c) of the distribution. Range: c > 0. + The location (μ) of the distribution. + a sequence of samples from the distribution. + + + + Generates a sample from the distribution. + + The stability (α) of the distribution. Range: 2 ≥ α > 0. + The skewness (β) of the distribution. Range: 1 ≥ β ≥ -1. + The scale (c) of the distribution. Range: c > 0. + The location (μ) of the distribution. + a sample from the distribution. + + + + Generates a sequence of samples from the distribution. + + The stability (α) of the distribution. Range: 2 ≥ α > 0. + The skewness (β) of the distribution. Range: 1 ≥ β ≥ -1. + The scale (c) of the distribution. Range: c > 0. + The location (μ) of the distribution. + a sequence of samples from the distribution. + + + + Fills an array with samples generated from the distribution. + + The array to fill with the samples. + The stability (α) of the distribution. Range: 2 ≥ α > 0. + The skewness (β) of the distribution. Range: 1 ≥ β ≥ -1. + The scale (c) of the distribution. Range: c > 0. + The location (μ) of the distribution. + a sequence of samples from the distribution. + + + + Continuous Univariate Student's T-distribution. + Implements the univariate Student t-distribution. For details about this + distribution, see + + Wikipedia - Student's t-distribution. + + We use a slightly generalized version (compared to + Wikipedia) of the Student t-distribution. Namely, one which also + parameterizes the location and scale. See the book "Bayesian Data + Analysis" by Gelman et al. for more details. + The density of the Student t-distribution p(x|mu,scale,dof) = + Gamma((dof+1)/2) (1 + (x - mu)^2 / (scale * scale * dof))^(-(dof+1)/2) / + (Gamma(dof/2)*Sqrt(dof*pi*scale)). + The distribution will use the by + default. Users can get/set the random number generator by using the + property. + The statistics classes will check all the incoming parameters + whether they are in the allowed range. This might involve heavy + computation. Optionally, by setting Control.CheckDistributionParameters + to false, all parameter checks can be turned off. + + + + Initializes a new instance of the StudentT class. This is a Student t-distribution with location 0.0 + scale 1.0 and degrees of freedom 1. + + + + + Initializes a new instance of the StudentT class with a particular location, scale and degrees of + freedom. + + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + The degrees of freedom (ν) for the distribution. Range: ν > 0. + + + + Initializes a new instance of the StudentT class with a particular location, scale and degrees of + freedom. + + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + The degrees of freedom (ν) for the distribution. Range: ν > 0. + The random number generator which is used to draw random samples. + + + + A string representation of the distribution. + + a string representation of the distribution. + + + + Tests whether the provided values are valid parameters for this distribution. + + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + The degrees of freedom (ν) for the distribution. Range: ν > 0. + + + + Gets the location (μ) of the Student t-distribution. + + + + + Gets the scale (σ) of the Student t-distribution. Range: σ > 0. + + + + + Gets the degrees of freedom (ν) of the Student t-distribution. Range: ν > 0. + + + + + Gets or sets the random number generator which is used to draw random samples. + + + + + Gets the mean of the Student t-distribution. + + + + + Gets the variance of the Student t-distribution. + + + + + Gets the standard deviation of the Student t-distribution. + + + + + Gets the entropy of the Student t-distribution. + + + + + Gets the skewness of the Student t-distribution. + + + + + Gets the mode of the Student t-distribution. + + + + + Gets the median of the Student t-distribution. + + + + + Gets the minimum of the Student t-distribution. + + + + + Gets the maximum of the Student t-distribution. + + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The location at which to compute the density. + the density at . + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The location at which to compute the log density. + the log density at . + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + the cumulative distribution at location . + + + + Computes the inverse of the cumulative distribution function (InvCDF) for the distribution + at the given probability. This is also known as the quantile or percent point function. + + The location at which to compute the inverse cumulative density. + the inverse cumulative density at . + + WARNING: currently not an explicit implementation, hence slow and unreliable. + + + + Samples student-t distributed random variables. + + The algorithm is method 2 in section 5, chapter 9 + in L. Devroye's "Non-Uniform Random Variate Generation" + The random number generator to use. + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + The degrees of freedom (ν) for the distribution. Range: ν > 0. + a random number from the standard student-t distribution. + + + + Generates a sample from the Student t-distribution. + + a sample from the distribution. + + + + Fills an array with samples generated from the distribution. + + + + + Generates a sequence of samples from the Student t-distribution. + + a sequence of samples from the distribution. + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + The degrees of freedom (ν) for the distribution. Range: ν > 0. + The location at which to compute the density. + the density at . + + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + The degrees of freedom (ν) for the distribution. Range: ν > 0. + The location at which to compute the density. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + The degrees of freedom (ν) for the distribution. Range: ν > 0. + the cumulative distribution at location . + + + + + Computes the inverse of the cumulative distribution function (InvCDF) for the distribution + at the given probability. This is also known as the quantile or percent point function. + + The location at which to compute the inverse cumulative density. + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + The degrees of freedom (ν) for the distribution. Range: ν > 0. + the inverse cumulative density at . + + WARNING: currently not an explicit implementation, hence slow and unreliable. + + + + Generates a sample from the Student t-distribution. + + The random number generator to use. + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + The degrees of freedom (ν) for the distribution. Range: ν > 0. + a sample from the distribution. + + + + Generates a sequence of samples from the Student t-distribution using the Box-Muller algorithm. + + The random number generator to use. + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + The degrees of freedom (ν) for the distribution. Range: ν > 0. + a sequence of samples from the distribution. + + + + Fills an array with samples generated from the distribution. + + The random number generator to use. + The array to fill with the samples. + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + The degrees of freedom (ν) for the distribution. Range: ν > 0. + a sequence of samples from the distribution. + + + + Generates a sample from the Student t-distribution. + + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + The degrees of freedom (ν) for the distribution. Range: ν > 0. + a sample from the distribution. + + + + Generates a sequence of samples from the Student t-distribution using the Box-Muller algorithm. + + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + The degrees of freedom (ν) for the distribution. Range: ν > 0. + a sequence of samples from the distribution. + + + + Fills an array with samples generated from the distribution. + + The array to fill with the samples. + The location (μ) of the distribution. + The scale (σ) of the distribution. Range: σ > 0. + The degrees of freedom (ν) for the distribution. Range: ν > 0. + a sequence of samples from the distribution. + + + + Triangular distribution. + For details, see Wikipedia - Triangular distribution. + + The distribution will use the by default. + Users can get/set the random number generator by using the property. + The statistics classes will check whether all the incoming parameters are in the allowed range. This might involve heavy computation. Optionally, by setting Control.CheckDistributionParameters + to false, all parameter checks can be turned off. + + + + Initializes a new instance of the Triangular class with the given lower bound, upper bound and mode. + + Lower bound. Range: lower ≤ mode ≤ upper + Upper bound. Range: lower ≤ mode ≤ upper + Mode (most frequent value). Range: lower ≤ mode ≤ upper + If the upper bound is smaller than the mode or if the mode is smaller than the lower bound. + + + + Initializes a new instance of the Triangular class with the given lower bound, upper bound and mode. + + Lower bound. Range: lower ≤ mode ≤ upper + Upper bound. Range: lower ≤ mode ≤ upper + Mode (most frequent value). Range: lower ≤ mode ≤ upper + The random number generator which is used to draw random samples. + If the upper bound is smaller than the mode or if the mode is smaller than the lower bound. + + + + A string representation of the distribution. + + a string representation of the distribution. + + + + Tests whether the provided values are valid parameters for this distribution. + + Lower bound. Range: lower ≤ mode ≤ upper + Upper bound. Range: lower ≤ mode ≤ upper + Mode (most frequent value). Range: lower ≤ mode ≤ upper + + + + Gets the lower bound of the distribution. + + + + + Gets the upper bound of the distribution. + + + + + Gets or sets the random number generator which is used to draw random samples. + + + + + Gets the mean of the distribution. + + + + + Gets the variance of the distribution. + + + + + Gets the standard deviation of the distribution. + + + + + Gets the entropy of the distribution. + + + + + + Gets the skewness of the distribution. + + + + + Gets or sets the mode of the distribution. + + + + + Gets the median of the distribution. + + + + + + Gets the minimum of the distribution. + + + + + Gets the maximum of the distribution. + + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The location at which to compute the density. + the density at . + + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The location at which to compute the log density. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + the cumulative distribution at location . + + + + + Computes the inverse of the cumulative distribution function (InvCDF) for the distribution + at the given probability. This is also known as the quantile or percent point function. + + The location at which to compute the inverse cumulative density. + the inverse cumulative density at . + + + + + Generates a sample from the Triangular distribution. + + a sample from the distribution. + + + + Fills an array with samples generated from the distribution. + + + + + Generates a sequence of samples from the Triangular distribution. + + a sequence of samples from the distribution. + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + Lower bound. Range: lower ≤ mode ≤ upper + Upper bound. Range: lower ≤ mode ≤ upper + Mode (most frequent value). Range: lower ≤ mode ≤ upper + The location at which to compute the density. + the density at . + + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + Lower bound. Range: lower ≤ mode ≤ upper + Upper bound. Range: lower ≤ mode ≤ upper + Mode (most frequent value). Range: lower ≤ mode ≤ upper + The location at which to compute the density. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + Lower bound. Range: lower ≤ mode ≤ upper + Upper bound. Range: lower ≤ mode ≤ upper + Mode (most frequent value). Range: lower ≤ mode ≤ upper + the cumulative distribution at location . + + + + + Computes the inverse of the cumulative distribution function (InvCDF) for the distribution + at the given probability. This is also known as the quantile or percent point function. + + The location at which to compute the inverse cumulative density. + Lower bound. Range: lower ≤ mode ≤ upper + Upper bound. Range: lower ≤ mode ≤ upper + Mode (most frequent value). Range: lower ≤ mode ≤ upper + the inverse cumulative density at . + + + + + Generates a sample from the Triangular distribution. + + The random number generator to use. + Lower bound. Range: lower ≤ mode ≤ upper + Upper bound. Range: lower ≤ mode ≤ upper + Mode (most frequent value). Range: lower ≤ mode ≤ upper + a sample from the distribution. + + + + Generates a sequence of samples from the Triangular distribution. + + The random number generator to use. + Lower bound. Range: lower ≤ mode ≤ upper + Upper bound. Range: lower ≤ mode ≤ upper + Mode (most frequent value). Range: lower ≤ mode ≤ upper + a sequence of samples from the distribution. + + + + Fills an array with samples generated from the distribution. + + The random number generator to use. + The array to fill with the samples. + Lower bound. Range: lower ≤ mode ≤ upper + Upper bound. Range: lower ≤ mode ≤ upper + Mode (most frequent value). Range: lower ≤ mode ≤ upper + a sequence of samples from the distribution. + + + + Generates a sample from the Triangular distribution. + + Lower bound. Range: lower ≤ mode ≤ upper + Upper bound. Range: lower ≤ mode ≤ upper + Mode (most frequent value). Range: lower ≤ mode ≤ upper + a sample from the distribution. + + + + Generates a sequence of samples from the Triangular distribution. + + Lower bound. Range: lower ≤ mode ≤ upper + Upper bound. Range: lower ≤ mode ≤ upper + Mode (most frequent value). Range: lower ≤ mode ≤ upper + a sequence of samples from the distribution. + + + + Fills an array with samples generated from the distribution. + + The array to fill with the samples. + Lower bound. Range: lower ≤ mode ≤ upper + Upper bound. Range: lower ≤ mode ≤ upper + Mode (most frequent value). Range: lower ≤ mode ≤ upper + a sequence of samples from the distribution. + + + + Initializes a new instance of the TruncatedPareto class. + + The scale (xm) of the distribution. Range: xm > 0. + The shape (α) of the distribution. Range: α > 0. + The truncation (T) of the distribution. Range: T > xm. + The random number generator which is used to draw random samples. + If or are non-positive or if T ≤ xm. + + + + A string representation of the distribution. + + a string representation of the distribution. + + + + Tests whether the provided values are valid parameters for this distribution. + + The scale (xm) of the distribution. Range: xm > 0. + The shape (α) of the distribution. Range: α > 0. + The truncation (T) of the distribution. Range: T > xm. + + + + Gets the random number generator which is used to draw random samples. + + + + + Gets the scale (xm) of the distribution. Range: xm > 0. + + + + + Gets the shape (α) of the distribution. Range: α > 0. + + + + + Gets the truncation (T) of the distribution. Range: T > 0. + + + + + Gets the n-th raw moment of the distribution. + + The order (n) of the moment. Range: n ≥ 1. + the n-th moment of the distribution. + + + + Gets the mean of the truncated Pareto distribution. + + + + + Gets the variance of the truncated Pareto distribution. + + + + + Gets the standard deviation of the truncated Pareto distribution. + + + + + Gets the mode of the truncated Pareto distribution (not supported). + + + + + Gets the minimum of the truncated Pareto distribution. + + + + + Gets the maximum of the truncated Pareto distribution. + + + + + Gets the entropy of the truncated Pareto distribution (not supported). + + + + + Gets the skewness of the truncated Pareto distribution. + + + + + Gets the median of the truncated Pareto distribution. + + + + + Generates a sample from the truncated Pareto distribution. + + a sample from the distribution. + + + + Fills an array with samples generated from the distribution. + + The array to fill with the samples. + + + + Generates a sequence of samples from the truncated Pareto distribution. + + a sequence of samples from the distribution. + + + + Generates a sample from the truncated Pareto distribution. + + The random number generator to use. + The scale (xm) of the distribution. Range: xm > 0. + The shape (α) of the distribution. Range: α > 0. + The truncation (T) of the distribution. Range: T > xm. + a sample from the distribution. + + + + Fills an array with samples generated from the distribution. + + The random number generator to use. + The array to fill with the samples. + The scale (xm) of the distribution. Range: xm > 0. + The shape (α) of the distribution. Range: α > 0. + The truncation (T) of the distribution. Range: T > xm. + + + + Generates a sequence of samples from the truncated Pareto distribution. + + The random number generator to use. + The scale (xm) of the distribution. Range: xm > 0. + The shape (α) of the distribution. Range: α > 0. + The truncation (T) of the distribution. Range: T > xm. + a sequence of samples from the distribution. + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The location at which to compute the density. + the density at . + + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The location at which to compute the log density. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + the cumulative distribution at location . + + + + + Computes the inverse cumulative distribution (CDF) of the distribution at p, i.e. solving for P(X ≤ x) = p. + + The location at which to compute the inverse cumulative distribution function. + the inverse cumulative distribution at location . + + + + Computes the inverse cumulative distribution (CDF) of the distribution at p, i.e. solving for P(X ≤ x) = p. + + The scale (xm) of the distribution. Range: xm > 0. + The shape (α) of the distribution. Range: α > 0. + The truncation (T) of the distribution. Range: T > xm. + The location at which to compute the inverse cumulative distribution function. + the inverse cumulative distribution at location . + + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The scale (xm) of the distribution. Range: xm > 0. + The shape (α) of the distribution. Range: α > 0. + The truncation (T) of the distribution. Range: T > xm. + The location at which to compute the density. + the density at . + + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The scale (xm) of the distribution. Range: xm > 0. + The shape (α) of the distribution. Range: α > 0. + The truncation (T) of the distribution. Range: T > xm. + The location at which to compute the log density. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The scale (xm) of the distribution. Range: xm > 0. + The shape (α) of the distribution. Range: α > 0. + The truncation (T) of the distribution. Range: T > xm. + The location at which to compute the cumulative distribution function. + the cumulative distribution at location . + + + + + Continuous Univariate Weibull distribution. + For details about this distribution, see + Wikipedia - Weibull distribution. + + + The Weibull distribution is parametrized by a shape and scale parameter. + + + + + Reusable intermediate result 1 / (_scale ^ _shape) + + + By caching this parameter we can get slightly better numerics precision + in certain constellations without any additional computations. + + + + + Initializes a new instance of the Weibull class. + + The shape (k) of the Weibull distribution. Range: k > 0. + The scale (λ) of the Weibull distribution. Range: λ > 0. + + + + Initializes a new instance of the Weibull class. + + The shape (k) of the Weibull distribution. Range: k > 0. + The scale (λ) of the Weibull distribution. Range: λ > 0. + The random number generator which is used to draw random samples. + + + + A string representation of the distribution. + + a string representation of the distribution. + + + + Tests whether the provided values are valid parameters for this distribution. + + The shape (k) of the Weibull distribution. Range: k > 0. + The scale (λ) of the Weibull distribution. Range: λ > 0. + + + + Gets the shape (k) of the Weibull distribution. Range: k > 0. + + + + + Gets the scale (λ) of the Weibull distribution. Range: λ > 0. + + + + + Gets or sets the random number generator which is used to draw random samples. + + + + + Gets the mean of the Weibull distribution. + + + + + Gets the variance of the Weibull distribution. + + + + + Gets the standard deviation of the Weibull distribution. + + + + + Gets the entropy of the Weibull distribution. + + + + + Gets the skewness of the Weibull distribution. + + + + + Gets the mode of the Weibull distribution. + + + + + Gets the median of the Weibull distribution. + + + + + Gets the minimum of the Weibull distribution. + + + + + Gets the maximum of the Weibull distribution. + + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The location at which to compute the density. + the density at . + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The location at which to compute the log density. + the log density at . + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + the cumulative distribution at location . + + + + Generates a sample from the Weibull distribution. + + a sample from the distribution. + + + + Fills an array with samples generated from the distribution. + + + + + Generates a sequence of samples from the Weibull distribution. + + a sequence of samples from the distribution. + + + + Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x. + + The shape (k) of the Weibull distribution. Range: k > 0. + The scale (λ) of the Weibull distribution. Range: λ > 0. + The location at which to compute the density. + the density at . + + + + + Computes the log probability density of the distribution (lnPDF) at x, i.e. ln(∂P(X ≤ x)/∂x). + + The shape (k) of the Weibull distribution. Range: k > 0. + The scale (λ) of the Weibull distribution. Range: λ > 0. + The location at which to compute the density. + the log density at . + + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + The shape (k) of the Weibull distribution. Range: k > 0. + The scale (λ) of the Weibull distribution. Range: λ > 0. + the cumulative distribution at location . + + + + + Implemented according to: Parameter estimation of the Weibull probability distribution, 1994, Hongzhu Qiao, Chris P. Tsokos + + + + Returns a Weibull distribution. + + + + Generates a sample from the Weibull distribution. + + The random number generator to use. + The shape (k) of the Weibull distribution. Range: k > 0. + The scale (λ) of the Weibull distribution. Range: λ > 0. + a sample from the distribution. + + + + Generates a sequence of samples from the Weibull distribution. + + The random number generator to use. + The shape (k) of the Weibull distribution. Range: k > 0. + The scale (λ) of the Weibull distribution. Range: λ > 0. + a sequence of samples from the distribution. + + + + Fills an array with samples generated from the distribution. + + The random number generator to use. + The array to fill with the samples. + The shape (k) of the Weibull distribution. Range: k > 0. + The scale (λ) of the Weibull distribution. Range: λ > 0. + a sequence of samples from the distribution. + + + + Generates a sample from the Weibull distribution. + + The shape (k) of the Weibull distribution. Range: k > 0. + The scale (λ) of the Weibull distribution. Range: λ > 0. + a sample from the distribution. + + + + Generates a sequence of samples from the Weibull distribution. + + The shape (k) of the Weibull distribution. Range: k > 0. + The scale (λ) of the Weibull distribution. Range: λ > 0. + a sequence of samples from the distribution. + + + + Fills an array with samples generated from the distribution. + + The array to fill with the samples. + The shape (k) of the Weibull distribution. Range: k > 0. + The scale (λ) of the Weibull distribution. Range: λ > 0. + a sequence of samples from the distribution. + + + + Multivariate Wishart distribution. This distribution is + parameterized by the degrees of freedom nu and the scale matrix S. The Wishart distribution + is the conjugate prior for the precision (inverse covariance) matrix of the multivariate + normal distribution. + Wikipedia - Wishart distribution. + + + + + The degrees of freedom for the Wishart distribution. + + + + + The scale matrix for the Wishart distribution. + + + + + Caches the Cholesky factorization of the scale matrix. + + + + + Initializes a new instance of the class. + + The degrees of freedom (n) for the Wishart distribution. + The scale matrix (V) for the Wishart distribution. + + + + Initializes a new instance of the class. + + The degrees of freedom (n) for the Wishart distribution. + The scale matrix (V) for the Wishart distribution. + The random number generator which is used to draw random samples. + + + + Tests whether the provided values are valid parameters for this distribution. + + The degrees of freedom (n) for the Wishart distribution. + The scale matrix (V) for the Wishart distribution. + + + + Gets or sets the degrees of freedom (n) for the Wishart distribution. + + + + + Gets or sets the scale matrix (V) for the Wishart distribution. + + + + + A string representation of the distribution. + + a string representation of the distribution. + + + + Gets or sets the random number generator which is used to draw random samples. + + + + + Gets the mean of the distribution. + + The mean of the distribution. + + + + Gets the mode of the distribution. + + The mode of the distribution. + + + + Gets the variance of the distribution. + + The variance of the distribution. + + + + Evaluates the probability density function for the Wishart distribution. + + The matrix at which to evaluate the density at. + If the argument does not have the same dimensions as the scale matrix. + the density at . + + + + Samples a Wishart distributed random variable using the method + Algorithm AS 53: Wishart Variate Generator + W. B. Smith and R. R. Hocking + Applied Statistics, Vol. 21, No. 3 (1972), pp. 341-345 + + A random number from this distribution. + + + + Samples a Wishart distributed random variable using the method + Algorithm AS 53: Wishart Variate Generator + W. B. Smith and R. R. Hocking + Applied Statistics, Vol. 21, No. 3 (1972), pp. 341-345 + + The random number generator to use. + The degrees of freedom (n) for the Wishart distribution. + The scale matrix (V) for the Wishart distribution. + a sequence of samples from the distribution. + + + + Samples the distribution. + + The random number generator to use. + The degrees of freedom (n) for the Wishart distribution. + The scale matrix (V) for the Wishart distribution. + The cholesky decomposition to use. + a random number from the distribution. + + + + Discrete Univariate Zipf distribution. + Zipf's law, an empirical law formulated using mathematical statistics, refers to the fact + that many types of data studied in the physical and social sciences can be approximated with + a Zipfian distribution, one of a family of related discrete power law probability distributions. + For details about this distribution, see + Wikipedia - Zipf distribution. + + + + + The s parameter of the distribution. + + + + + The n parameter of the distribution. + + + + + Initializes a new instance of the class. + + The s parameter of the distribution. + The n parameter of the distribution. + + + + Initializes a new instance of the class. + + The s parameter of the distribution. + The n parameter of the distribution. + The random number generator which is used to draw random samples. + + + + A string representation of the distribution. + + a string representation of the distribution. + + + + Tests whether the provided values are valid parameters for this distribution. + + The s parameter of the distribution. + The n parameter of the distribution. + + + + Gets or sets the s parameter of the distribution. + + + + + Gets or sets the n parameter of the distribution. + + + + + Gets or sets the random number generator which is used to draw random samples. + + + + + Gets the mean of the distribution. + + + + + Gets the variance of the distribution. + + + + + Gets the standard deviation of the distribution. + + + + + Gets the entropy of the distribution. + + + + + Gets the skewness of the distribution. + + + + + Gets the mode of the distribution. + + + + + Gets the median of the distribution. + + + + + Gets the smallest element in the domain of the distributions which can be represented by an integer. + + + + + Gets the largest element in the domain of the distributions which can be represented by an integer. + + + + + Computes the probability mass (PMF) at k, i.e. P(X = k). + + The location in the domain where we want to evaluate the probability mass function. + the probability mass at location . + + + + Computes the log probability mass (lnPMF) at k, i.e. ln(P(X = k)). + + The location in the domain where we want to evaluate the log probability mass function. + the log probability mass at location . + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + the cumulative distribution at location . + + + + Computes the probability mass (PMF) at k, i.e. P(X = k). + + The location in the domain where we want to evaluate the probability mass function. + The s parameter of the distribution. + The n parameter of the distribution. + the probability mass at location . + + + + Computes the log probability mass (lnPMF) at k, i.e. ln(P(X = k)). + + The location in the domain where we want to evaluate the log probability mass function. + The s parameter of the distribution. + The n parameter of the distribution. + the log probability mass at location . + + + + Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x). + + The location at which to compute the cumulative distribution function. + The s parameter of the distribution. + The n parameter of the distribution. + the cumulative distribution at location . + + + + + Generates a sample from the Zipf distribution without doing parameter checking. + + The random number generator to use. + The s parameter of the distribution. + The n parameter of the distribution. + a random number from the Zipf distribution. + + + + Draws a random sample from the distribution. + + a sample from the distribution. + + + + Fills an array with samples generated from the distribution. + + + + + Samples an array of zipf distributed random variables. + + a sequence of samples from the distribution. + + + + Samples a random variable. + + The random number generator to use. + The s parameter of the distribution. + The n parameter of the distribution. + + + + Samples a sequence of this random variable. + + The random number generator to use. + The s parameter of the distribution. + The n parameter of the distribution. + + + + Fills an array with samples generated from the distribution. + + The random number generator to use. + The array to fill with the samples. + The s parameter of the distribution. + The n parameter of the distribution. + + + + Samples a random variable. + + The s parameter of the distribution. + The n parameter of the distribution. + + + + Samples a sequence of this random variable. + + The s parameter of the distribution. + The n parameter of the distribution. + + + + Fills an array with samples generated from the distribution. + + The array to fill with the samples. + The s parameter of the distribution. + The n parameter of the distribution. + + + + Integer number theory functions. + + + + + Canonical Modulus. The result has the sign of the divisor. + + + + + Canonical Modulus. The result has the sign of the divisor. + + + + + Canonical Modulus. The result has the sign of the divisor. + + + + + Canonical Modulus. The result has the sign of the divisor. + + + + + Canonical Modulus. The result has the sign of the divisor. + + + + + Remainder (% operator). The result has the sign of the dividend. + + + + + Remainder (% operator). The result has the sign of the dividend. + + + + + Remainder (% operator). The result has the sign of the dividend. + + + + + Remainder (% operator). The result has the sign of the dividend. + + + + + Remainder (% operator). The result has the sign of the dividend. + + + + + Find out whether the provided 32 bit integer is an even number. + + The number to very whether it's even. + True if and only if it is an even number. + + + + Find out whether the provided 64 bit integer is an even number. + + The number to very whether it's even. + True if and only if it is an even number. + + + + Find out whether the provided 32 bit integer is an odd number. + + The number to very whether it's odd. + True if and only if it is an odd number. + + + + Find out whether the provided 64 bit integer is an odd number. + + The number to very whether it's odd. + True if and only if it is an odd number. + + + + Find out whether the provided 32 bit integer is a perfect power of two. + + The number to very whether it's a power of two. + True if and only if it is a power of two. + + + + Find out whether the provided 64 bit integer is a perfect power of two. + + The number to very whether it's a power of two. + True if and only if it is a power of two. + + + + Find out whether the provided 32 bit integer is a perfect square, i.e. a square of an integer. + + The number to very whether it's a perfect square. + True if and only if it is a perfect square. + + + + Find out whether the provided 64 bit integer is a perfect square, i.e. a square of an integer. + + The number to very whether it's a perfect square. + True if and only if it is a perfect square. + + + + Raises 2 to the provided integer exponent (0 <= exponent < 31). + + The exponent to raise 2 up to. + 2 ^ exponent. + + + + + Raises 2 to the provided integer exponent (0 <= exponent < 63). + + The exponent to raise 2 up to. + 2 ^ exponent. + + + + + Evaluate the binary logarithm of an integer number. + + Two-step method using a De Bruijn-like sequence table lookup. + + + + Find the closest perfect power of two that is larger or equal to the provided + 32 bit integer. + + The number of which to find the closest upper power of two. + A power of two. + + + + + Find the closest perfect power of two that is larger or equal to the provided + 64 bit integer. + + The number of which to find the closest upper power of two. + A power of two. + + + + + Returns the greatest common divisor (gcd) of two integers using Euclid's algorithm. + + First Integer: a. + Second Integer: b. + Greatest common divisor gcd(a,b) + + + + Returns the greatest common divisor (gcd) of a set of integers using Euclid's + algorithm. + + List of Integers. + Greatest common divisor gcd(list of integers) + + + + Returns the greatest common divisor (gcd) of a set of integers using Euclid's algorithm. + + List of Integers. + Greatest common divisor gcd(list of integers) + + + + Computes the extended greatest common divisor, such that a*x + b*y = gcd(a,b). + + First Integer: a. + Second Integer: b. + Resulting x, such that a*x + b*y = gcd(a,b). + Resulting y, such that a*x + b*y = gcd(a,b) + Greatest common divisor gcd(a,b) + + + long x,y,d; + d = Fn.GreatestCommonDivisor(45,18,out x, out y); + -> d == 9 && x == 1 && y == -2 + + The gcd of 45 and 18 is 9: 18 = 2*9, 45 = 5*9. 9 = 1*45 -2*18, therefore x=1 and y=-2. + + + + + Returns the least common multiple (lcm) of two integers using Euclid's algorithm. + + First Integer: a. + Second Integer: b. + Least common multiple lcm(a,b) + + + + Returns the least common multiple (lcm) of a set of integers using Euclid's algorithm. + + List of Integers. + Least common multiple lcm(list of integers) + + + + Returns the least common multiple (lcm) of a set of integers using Euclid's algorithm. + + List of Integers. + Least common multiple lcm(list of integers) + + + + Returns the greatest common divisor (gcd) of two big integers. + + First Integer: a. + Second Integer: b. + Greatest common divisor gcd(a,b) + + + + Returns the greatest common divisor (gcd) of a set of big integers. + + List of Integers. + Greatest common divisor gcd(list of integers) + + + + Returns the greatest common divisor (gcd) of a set of big integers. + + List of Integers. + Greatest common divisor gcd(list of integers) + + + + Computes the extended greatest common divisor, such that a*x + b*y = gcd(a,b). + + First Integer: a. + Second Integer: b. + Resulting x, such that a*x + b*y = gcd(a,b). + Resulting y, such that a*x + b*y = gcd(a,b) + Greatest common divisor gcd(a,b) + + + long x,y,d; + d = Fn.GreatestCommonDivisor(45,18,out x, out y); + -> d == 9 && x == 1 && y == -2 + + The gcd of 45 and 18 is 9: 18 = 2*9, 45 = 5*9. 9 = 1*45 -2*18, therefore x=1 and y=-2. + + + + + Returns the least common multiple (lcm) of two big integers. + + First Integer: a. + Second Integer: b. + Least common multiple lcm(a,b) + + + + Returns the least common multiple (lcm) of a set of big integers. + + List of Integers. + Least common multiple lcm(list of integers) + + + + Returns the least common multiple (lcm) of a set of big integers. + + List of Integers. + Least common multiple lcm(list of integers) + + + + Collection of functions equivalent to those provided by Microsoft Excel + but backed instead by Math.NET Numerics. + We do not recommend to use them except in an intermediate phase when + porting over solutions previously implemented in Excel. + + + + + An algorithm failed to converge. + + + + + An algorithm failed to converge due to a numerical breakdown. + + + + + An error occurred calling native provider function. + + + + + An error occurred calling native provider function. + + + + + Native provider was unable to allocate sufficient memory. + + + + + Native provider failed LU inversion do to a singular U matrix. + + + + + Compound Monthly Return or Geometric Return or Annualized Return + + + + + Average Gain or Gain Mean + This is a simple average (arithmetic mean) of the periods with a gain. It is calculated by summing the returns for gain periods (return 0) + and then dividing the total by the number of gain periods. + + http://www.offshore-library.com/kb/statistics.php + + + + Average Loss or LossMean + This is a simple average (arithmetic mean) of the periods with a loss. It is calculated by summing the returns for loss periods (return < 0) + and then dividing the total by the number of loss periods. + + http://www.offshore-library.com/kb/statistics.php + + + + Calculation is similar to Standard Deviation , except it calculates an average (mean) return only for periods with a gain + and measures the variation of only the gain periods around the gain mean. Measures the volatility of upside performance. + © Copyright 1996, 1999 Gary L.Gastineau. First Edition. © 1992 Swiss Bank Corporation. + + + + + Similar to standard deviation, except this statistic calculates an average (mean) return for only the periods with a loss and then + measures the variation of only the losing periods around this loss mean. This statistic measures the volatility of downside performance. + + http://www.offshore-library.com/kb/statistics.php + + + + This measure is similar to the loss standard deviation except the downside deviation + considers only returns that fall below a defined minimum acceptable return (MAR) rather than the arithmetic mean. + For example, if the MAR is 7%, the downside deviation would measure the variation of each period that falls below + 7%. (The loss standard deviation, on the other hand, would take only losing periods, calculate an average return for + the losing periods, and then measure the variation between each losing return and the losing return average). + + + + + A measure of volatility in returns below the mean. It's similar to standard deviation, but it only + looks at periods where the investment return was less than average return. + + + + + Measures a fund’s average gain in a gain period divided by the fund’s average loss in a losing + period. Periods can be monthly or quarterly depending on the data frequency. + + + + + Find value x that minimizes the scalar function f(x), constrained within bounds, using the Golden Section algorithm. + For more options and diagnostics consider to use directly. + + + + + Find vector x that minimizes the function f(x) using the Nelder-Mead Simplex algorithm. + For more options and diagnostics consider to use directly. + + + + + Find vector x that minimizes the function f(x) using the Nelder-Mead Simplex algorithm. + For more options and diagnostics consider to use directly. + + + + + Find vector x that minimizes the function f(x) using the Nelder-Mead Simplex algorithm. + For more options and diagnostics consider to use directly. + + + + + Find vector x that minimizes the function f(x) using the Nelder-Mead Simplex algorithm. + For more options and diagnostics consider to use directly. + + + + + Find vector x that minimizes the function f(x) using the Nelder-Mead Simplex algorithm. + For more options and diagnostics consider to use directly. + + + + + Find vector x that minimizes the function f(x) using the Nelder-Mead Simplex algorithm. + For more options and diagnostics consider to use directly. + + + + + Find vector x that minimizes the function f(x), constrained within bounds, using the Broyden–Fletcher–Goldfarb–Shanno Bounded (BFGS-B) algorithm. + The missing gradient is evaluated numerically (forward difference). + For more options and diagnostics consider to use directly. + + + + + Find vector x that minimizes the function f(x) using the Broyden–Fletcher–Goldfarb–Shanno (BFGS) algorithm. + For more options and diagnostics consider to use directly. + An alternative routine using conjugate gradients (CG) is available in . + + + + + Find vector x that minimizes the function f(x) using the Broyden–Fletcher–Goldfarb–Shanno (BFGS) algorithm. + For more options and diagnostics consider to use directly. + An alternative routine using conjugate gradients (CG) is available in . + + + + + Find vector x that minimizes the function f(x), constrained within bounds, using the Broyden–Fletcher–Goldfarb–Shanno Bounded (BFGS-B) algorithm. + For more options and diagnostics consider to use directly. + + + + + Find vector x that minimizes the function f(x), constrained within bounds, using the Broyden–Fletcher–Goldfarb–Shanno Bounded (BFGS-B) algorithm. + For more options and diagnostics consider to use directly. + + + + + Find vector x that minimizes the function f(x) using the Newton algorithm. + For more options and diagnostics consider to use directly. + + + + + Find vector x that minimizes the function f(x) using the Newton algorithm. + For more options and diagnostics consider to use directly. + + + + Find a solution of the equation f(x)=0. + The function to find roots from. + The low value of the range where the root is supposed to be. + The high value of the range where the root is supposed to be. + Desired accuracy. The root will be refined until the accuracy or the maximum number of iterations is reached. Example: 1e-14. + Maximum number of iterations. Example: 100. + + + Find a solution of the equation f(x)=0. + The function to find roots from. + The first derivative of the function to find roots from. + The low value of the range where the root is supposed to be. + The high value of the range where the root is supposed to be. + Desired accuracy. The root will be refined until the accuracy or the maximum number of iterations is reached. Example: 1e-14. + Maximum number of iterations. Example: 100. + + + + Find both complex roots of the quadratic equation c + b*x + a*x^2 = 0. + Note the special coefficient order ascending by exponent (consistent with polynomials). + + + + + Find all three complex roots of the cubic equation d + c*x + b*x^2 + a*x^3 = 0. + Note the special coefficient order ascending by exponent (consistent with polynomials). + + + + + Find all roots of a polynomial by calculating the characteristic polynomial of the companion matrix + + The coefficients of the polynomial in ascending order, e.g. new double[] {5, 0, 2} = "5 + 0 x^1 + 2 x^2" + The roots of the polynomial + + + + Find all roots of a polynomial by calculating the characteristic polynomial of the companion matrix + + The polynomial. + The roots of the polynomial + + + + Find all roots of the Chebychev polynomial of the first kind. + + The polynomial order and therefore the number of roots. + The real domain interval begin where to start sampling. + The real domain interval end where to stop sampling. + Samples in [a,b] at (b+a)/2+(b-1)/2*cos(pi*(2i-1)/(2n)) + + + + Find all roots of the Chebychev polynomial of the second kind. + + The polynomial order and therefore the number of roots. + The real domain interval begin where to start sampling. + The real domain interval end where to stop sampling. + Samples in [a,b] at (b+a)/2+(b-1)/2*cos(pi*i/(n-1)) + + + + Least-Squares Curve Fitting Routines + + + + + Least-Squares fitting the points (x,y) to a line y : x -> a+b*x, + returning its best fitting parameters as (a, b) tuple, + where a is the intercept and b the slope. + + + + + Least-Squares fitting the points (x,y) to a line y : x -> a+b*x, + returning a function y' for the best fitting line. + + + + + Least-Squares fitting the points (x,y) to a line through origin y : x -> b*x, + returning its best fitting parameter b, + where the intercept is zero and b the slope. + + + + + Least-Squares fitting the points (x,y) to a line through origin y : x -> b*x, + returning a function y' for the best fitting line. + + + + + Least-Squares fitting the points (x,y) to an exponential y : x -> a*exp(r*x), + returning its best fitting parameters as (a, r) tuple. + + + + + Least-Squares fitting the points (x,y) to an exponential y : x -> a*exp(r*x), + returning a function y' for the best fitting line. + + + + + Least-Squares fitting the points (x,y) to a logarithm y : x -> a + b*ln(x), + returning its best fitting parameters as (a, b) tuple. + + + + + Least-Squares fitting the points (x,y) to a logarithm y : x -> a + b*ln(x), + returning a function y' for the best fitting line. + + + + + Least-Squares fitting the points (x,y) to a power y : x -> a*x^b, + returning its best fitting parameters as (a, b) tuple. + + + + + Least-Squares fitting the points (x,y) to a power y : x -> a*x^b, + returning a function y' for the best fitting line. + + + + + Least-Squares fitting the points (x,y) to a k-order polynomial y : x -> p0 + p1*x + p2*x^2 + ... + pk*x^k, + returning its best fitting parameters as [p0, p1, p2, ..., pk] array, compatible with Polynomial.Evaluate. + A polynomial with order/degree k has (k+1) coefficients and thus requires at least (k+1) samples. + + + + + Least-Squares fitting the points (x,y) to a k-order polynomial y : x -> p0 + p1*x + p2*x^2 + ... + pk*x^k, + returning a function y' for the best fitting polynomial. + A polynomial with order/degree k has (k+1) coefficients and thus requires at least (k+1) samples. + + + + + Weighted Least-Squares fitting the points (x,y) and weights w to a k-order polynomial y : x -> p0 + p1*x + p2*x^2 + ... + pk*x^k, + returning its best fitting parameters as [p0, p1, p2, ..., pk] array, compatible with Polynomial.Evaluate. + A polynomial with order/degree k has (k+1) coefficients and thus requires at least (k+1) samples. + + + + + Least-Squares fitting the points (x,y) to an arbitrary linear combination y : x -> p0*f0(x) + p1*f1(x) + ... + pk*fk(x), + returning its best fitting parameters as [p0, p1, p2, ..., pk] array. + + + + + Least-Squares fitting the points (x,y) to an arbitrary linear combination y : x -> p0*f0(x) + p1*f1(x) + ... + pk*fk(x), + returning a function y' for the best fitting combination. + + + + + Least-Squares fitting the points (x,y) to an arbitrary linear combination y : x -> p0*f0(x) + p1*f1(x) + ... + pk*fk(x), + returning its best fitting parameters as [p0, p1, p2, ..., pk] array. + + + + + Least-Squares fitting the points (x,y) to an arbitrary linear combination y : x -> p0*f0(x) + p1*f1(x) + ... + pk*fk(x), + returning a function y' for the best fitting combination. + + + + + Least-Squares fitting the points (X,y) = ((x0,x1,..,xk),y) to a linear surface y : X -> p0*x0 + p1*x1 + ... + pk*xk, + returning its best fitting parameters as [p0, p1, p2, ..., pk] array. + If an intercept is added, its coefficient will be prepended to the resulting parameters. + + + + + Least-Squares fitting the points (X,y) = ((x0,x1,..,xk),y) to a linear surface y : X -> p0*x0 + p1*x1 + ... + pk*xk, + returning a function y' for the best fitting combination. + If an intercept is added, its coefficient will be prepended to the resulting parameters. + + + + + Weighted Least-Squares fitting the points (X,y) = ((x0,x1,..,xk),y) and weights w to a linear surface y : X -> p0*x0 + p1*x1 + ... + pk*xk, + returning its best fitting parameters as [p0, p1, p2, ..., pk] array. + + + + + Least-Squares fitting the points (X,y) = ((x0,x1,..,xk),y) to an arbitrary linear combination y : X -> p0*f0(x) + p1*f1(x) + ... + pk*fk(x), + returning its best fitting parameters as [p0, p1, p2, ..., pk] array. + + + + + Least-Squares fitting the points (X,y) = ((x0,x1,..,xk),y) to an arbitrary linear combination y : X -> p0*f0(x) + p1*f1(x) + ... + pk*fk(x), + returning a function y' for the best fitting combination. + + + + + Least-Squares fitting the points (X,y) = ((x0,x1,..,xk),y) to an arbitrary linear combination y : X -> p0*f0(x) + p1*f1(x) + ... + pk*fk(x), + returning its best fitting parameters as [p0, p1, p2, ..., pk] array. + + + + + Least-Squares fitting the points (X,y) = ((x0,x1,..,xk),y) to an arbitrary linear combination y : X -> p0*f0(x) + p1*f1(x) + ... + pk*fk(x), + returning a function y' for the best fitting combination. + + + + + Least-Squares fitting the points (T,y) = (T,y) to an arbitrary linear combination y : X -> p0*f0(T) + p1*f1(T) + ... + pk*fk(T), + returning its best fitting parameters as [p0, p1, p2, ..., pk] array. + + + + + Least-Squares fitting the points (T,y) = (T,y) to an arbitrary linear combination y : X -> p0*f0(T) + p1*f1(T) + ... + pk*fk(T), + returning a function y' for the best fitting combination. + + + + + Least-Squares fitting the points (T,y) = (T,y) to an arbitrary linear combination y : X -> p0*f0(T) + p1*f1(T) + ... + pk*fk(T), + returning its best fitting parameters as [p0, p1, p2, ..., pk] array. + + + + + Least-Squares fitting the points (T,y) = (T,y) to an arbitrary linear combination y : X -> p0*f0(T) + p1*f1(T) + ... + pk*fk(T), + returning a function y' for the best fitting combination. + + + + + Non-linear least-squares fitting the points (x,y) to an arbitrary function y : x -> f(p, x), + returning its best fitting parameter p. + + + + + Non-linear least-squares fitting the points (x,y) to an arbitrary function y : x -> f(p0, p1, x), + returning its best fitting parameter p0 and p1. + + + + + Non-linear least-squares fitting the points (x,y) to an arbitrary function y : x -> f(p0, p1, p2, x), + returning its best fitting parameter p0, p1 and p2. + + + + + Non-linear least-squares fitting the points (x,y) to an arbitrary function y : x -> f(p0, p1, p2, p3, x), + returning its best fitting parameter p0, p1, p2 and p3. + + + + + Non-linear least-squares fitting the points (x,y) to an arbitrary function y : x -> f(p0, p1, p2, p3, p4, x), + returning its best fitting parameter p0, p1, p2, p3 and p4. + + + + + Non-linear least-squares fitting the points (x,y) to an arbitrary function y : x -> f(p, x), + returning a function y' for the best fitting curve. + + + + + Non-linear least-squares fitting the points (x,y) to an arbitrary function y : x -> f(p0, p1, x), + returning a function y' for the best fitting curve. + + + + + Non-linear least-squares fitting the points (x,y) to an arbitrary function y : x -> f(p0, p1, p2, x), + returning a function y' for the best fitting curve. + + + + + Non-linear least-squares fitting the points (x,y) to an arbitrary function y : x -> f(p0, p1, p2, p3, x), + returning a function y' for the best fitting curve. + + + + + Non-linear least-squares fitting the points (x,y) to an arbitrary function y : x -> f(p0, p1, p2, p3, p4, x), + returning a function y' for the best fitting curve. + + + + + Generate samples by sampling a function at the provided points. + + + + + Generate a sample sequence by sampling a function at the provided point sequence. + + + + + Generate samples by sampling a function at the provided points. + + + + + Generate a sample sequence by sampling a function at the provided point sequence. + + + + + Generate a linearly spaced sample vector of the given length between the specified values (inclusive). + Equivalent to MATLAB linspace but with the length as first instead of last argument. + + + + + Generate samples by sampling a function at linearly spaced points between the specified values (inclusive). + + + + + Generate a base 10 logarithmically spaced sample vector of the given length between the specified decade exponents (inclusive). + Equivalent to MATLAB logspace but with the length as first instead of last argument. + + + + + Generate samples by sampling a function at base 10 logarithmically spaced points between the specified decade exponents (inclusive). + + + + + Generate a linearly spaced sample vector within the inclusive interval (start, stop) and step 1. + Equivalent to MATLAB colon operator (:). + + + + + Generate a linearly spaced sample vector within the inclusive interval (start, stop) and step 1. + Equivalent to MATLAB colon operator (:). + + + + + Generate a linearly spaced sample vector within the inclusive interval (start, stop) and the provided step. + The start value is aways included as first value, but stop is only included if it stop-start is a multiple of step. + Equivalent to MATLAB double colon operator (::). + + + + + Generate a linearly spaced sample vector within the inclusive interval (start, stop) and the provided step. + The start value is aways included as first value, but stop is only included if it stop-start is a multiple of step. + Equivalent to MATLAB double colon operator (::). + + + + + Generate a linearly spaced sample vector within the inclusive interval (start, stop) and the provide step. + The start value is aways included as first value, but stop is only included if it stop-start is a multiple of step. + Equivalent to MATLAB double colon operator (::). + + + + + Generate samples by sampling a function at linearly spaced points within the inclusive interval (start, stop) and the provide step. + The start value is aways included as first value, but stop is only included if it stop-start is a multiple of step. + + + + + Create a periodic wave. + + The number of samples to generate. + Samples per time unit (Hz). Must be larger than twice the frequency to satisfy the Nyquist criterion. + Frequency in periods per time unit (Hz). + The length of the period when sampled at one sample per time unit. This is the interval of the periodic domain, a typical value is 1.0, or 2*Pi for angular functions. + Optional phase offset. + Optional delay, relative to the phase. + + + + Create a periodic wave. + + The number of samples to generate. + The function to apply to each of the values and evaluate the resulting sample. + Samples per time unit (Hz). Must be larger than twice the frequency to satisfy the Nyquist criterion. + Frequency in periods per time unit (Hz). + The length of the period when sampled at one sample per time unit. This is the interval of the periodic domain, a typical value is 1.0, or 2*Pi for angular functions. + Optional phase offset. + Optional delay, relative to the phase. + + + + Create an infinite periodic wave sequence. + + Samples per time unit (Hz). Must be larger than twice the frequency to satisfy the Nyquist criterion. + Frequency in periods per time unit (Hz). + The length of the period when sampled at one sample per time unit. This is the interval of the periodic domain, a typical value is 1.0, or 2*Pi for angular functions. + Optional phase offset. + Optional delay, relative to the phase. + + + + Create an infinite periodic wave sequence. + + The function to apply to each of the values and evaluate the resulting sample. + Samples per time unit (Hz). Must be larger than twice the frequency to satisfy the Nyquist criterion. + Frequency in periods per time unit (Hz). + The length of the period when sampled at one sample per time unit. This is the interval of the periodic domain, a typical value is 1.0, or 2*Pi for angular functions. + Optional phase offset. + Optional delay, relative to the phase. + + + + Create a Sine wave. + + The number of samples to generate. + Samples per time unit (Hz). Must be larger than twice the frequency to satisfy the Nyquist criterion. + Frequency in periods per time unit (Hz). + The maximal reached peak. + The mean, or DC part, of the signal. + Optional phase offset. + Optional delay, relative to the phase. + + + + Create an infinite Sine wave sequence. + + Samples per unit. + Frequency in samples per unit. + The maximal reached peak. + The mean, or DC part, of the signal. + Optional phase offset. + Optional delay, relative to the phase. + + + + Create a periodic square wave, starting with the high phase. + + The number of samples to generate. + Number of samples of the high phase. + Number of samples of the low phase. + Sample value to be emitted during the low phase. + Sample value to be emitted during the high phase. + Optional delay. + + + + Create an infinite periodic square wave sequence, starting with the high phase. + + Number of samples of the high phase. + Number of samples of the low phase. + Sample value to be emitted during the low phase. + Sample value to be emitted during the high phase. + Optional delay. + + + + Create a periodic triangle wave, starting with the raise phase from the lowest sample. + + The number of samples to generate. + Number of samples of the raise phase. + Number of samples of the fall phase. + Lowest sample value. + Highest sample value. + Optional delay. + + + + Create an infinite periodic triangle wave sequence, starting with the raise phase from the lowest sample. + + Number of samples of the raise phase. + Number of samples of the fall phase. + Lowest sample value. + Highest sample value. + Optional delay. + + + + Create a periodic sawtooth wave, starting with the lowest sample. + + The number of samples to generate. + Number of samples a full sawtooth period. + Lowest sample value. + Highest sample value. + Optional delay. + + + + Create an infinite periodic sawtooth wave sequence, starting with the lowest sample. + + Number of samples a full sawtooth period. + Lowest sample value. + Highest sample value. + Optional delay. + + + + Create an array with each field set to the same value. + + The number of samples to generate. + The value that each field should be set to. + + + + Create an infinite sequence where each element has the same value. + + The value that each element should be set to. + + + + Create a Heaviside Step sample vector. + + The number of samples to generate. + The maximal reached peak. + Offset to the time axis. + + + + Create an infinite Heaviside Step sample sequence. + + The maximal reached peak. + Offset to the time axis. + + + + Create a Kronecker Delta impulse sample vector. + + The number of samples to generate. + The maximal reached peak. + Offset to the time axis. Zero or positive. + + + + Create a Kronecker Delta impulse sample vector. + + The maximal reached peak. + Offset to the time axis, hence the sample index of the impulse. + + + + Create a periodic Kronecker Delta impulse sample vector. + + The number of samples to generate. + impulse sequence period. + The maximal reached peak. + Offset to the time axis. Zero or positive. + + + + Create a Kronecker Delta impulse sample vector. + + impulse sequence period. + The maximal reached peak. + Offset to the time axis. Zero or positive. + + + + Generate samples generated by the given computation. + + + + + Generate samples generated by the given computation. + + + + + Generate an infinite sequence generated by the given computation. + + + + + Generate an infinite sequence generated by the given computation. + + + + + Generate a Fibonacci sequence, including zero as first value. + + + + + Generate an infinite Fibonacci sequence, including zero as first value. + + + + + Create random samples, uniform between 0 and 1. + Faster than other methods but with reduced guarantees on randomness. + + + + + Create an infinite random sample sequence, uniform between 0 and 1. + Faster than other methods but with reduced guarantees on randomness. + + + + + Generate samples by sampling a function at samples from a probability distribution, uniform between 0 and 1. + Faster than other methods but with reduced guarantees on randomness. + + + + + Generate a sample sequence by sampling a function at samples from a probability distribution, uniform between 0 and 1. + Faster than other methods but with reduced guarantees on randomness. + + + + + Generate samples by sampling a function at sample pairs from a probability distribution, uniform between 0 and 1. + Faster than other methods but with reduced guarantees on randomness. + + + + + Generate a sample sequence by sampling a function at sample pairs from a probability distribution, uniform between 0 and 1. + Faster than other methods but with reduced guarantees on randomness. + + + + + Create samples with independent amplitudes of standard distribution. + + + + + Create an infinite sample sequence with independent amplitudes of standard distribution. + + + + + Create samples with independent amplitudes of normal distribution and a flat spectral density. + + + + + Create an infinite sample sequence with independent amplitudes of normal distribution and a flat spectral density. + + + + + Create random samples. + + + + + Create an infinite random sample sequence. + + + + + Create random samples. + + + + + Create an infinite random sample sequence. + + + + + Create random samples. + + + + + Create an infinite random sample sequence. + + + + + Create random samples. + + + + + Create an infinite random sample sequence. + + + + + Generate samples by sampling a function at samples from a probability distribution. + + + + + Generate a sample sequence by sampling a function at samples from a probability distribution. + + + + + Generate samples by sampling a function at sample pairs from a probability distribution. + + + + + Generate a sample sequence by sampling a function at sample pairs from a probability distribution. + + + + + Globalized String Handling Helpers + + + + + Tries to get a from the format provider, + returning the current culture if it fails. + + + An that supplies culture-specific + formatting information. + + A instance. + + + + Tries to get a from the format + provider, returning the current culture if it fails. + + + An that supplies culture-specific + formatting information. + + A instance. + + + + Tries to get a from the format provider, returning the current culture if it fails. + + + An that supplies culture-specific + formatting information. + + A instance. + + + + Globalized Parsing: Tokenize a node by splitting it into several nodes. + + Node that contains the trimmed string to be tokenized. + List of keywords to tokenize by. + keywords to skip looking for (because they've already been handled). + + + + Globalized Parsing: Parse a double number + + First token of the number. + Culture Info. + The parsed double number using the given culture information. + + + + + Globalized Parsing: Parse a float number + + First token of the number. + Culture Info. + The parsed float number using the given culture information. + + + + + Calculates r^2, the square of the sample correlation coefficient between + the observed outcomes and the observed predictor values. + Not to be confused with R^2, the coefficient of determination, see . + + The modelled/predicted values + The observed/actual values + Squared Person product-momentum correlation coefficient. + + + + Calculates r, the sample correlation coefficient between the observed outcomes + and the observed predictor values. + + The modelled/predicted values + The observed/actual values + Person product-momentum correlation coefficient. + + + + Calculates the Standard Error of the regression, given a sequence of + modeled/predicted values, and a sequence of actual/observed values + + The modelled/predicted values + The observed/actual values + The Standard Error of the regression + + + + Calculates the Standard Error of the regression, given a sequence of + modeled/predicted values, and a sequence of actual/observed values + + The modelled/predicted values + The observed/actual values + The degrees of freedom by which the + number of samples is reduced for performing the Standard Error calculation + The Standard Error of the regression + + + + Calculates the R-Squared value, also known as coefficient of determination, + given some modelled and observed values. + + The values expected from the model. + The actual values obtained. + Coefficient of determination. + + + + Complex Fast (FFT) Implementation of the Discrete Fourier Transform (DFT). + + + + + Applies the forward Fast Fourier Transform (FFT) to arbitrary-length sample vectors. + + Sample vector, where the FFT is evaluated in place. + + + + Applies the forward Fast Fourier Transform (FFT) to arbitrary-length sample vectors. + + Sample vector, where the FFT is evaluated in place. + + + + Applies the forward Fast Fourier Transform (FFT) to arbitrary-length sample vectors. + + Sample vector, where the FFT is evaluated in place. + Fourier Transform Convention Options. + + + + Applies the forward Fast Fourier Transform (FFT) to arbitrary-length sample vectors. + + Sample vector, where the FFT is evaluated in place. + Fourier Transform Convention Options. + + + + Applies the forward Fast Fourier Transform (FFT) to arbitrary-length sample vectors. + + Real part of the sample vector, where the FFT is evaluated in place. + Imaginary part of the sample vector, where the FFT is evaluated in place. + Fourier Transform Convention Options. + + + + Applies the forward Fast Fourier Transform (FFT) to arbitrary-length sample vectors. + + Real part of the sample vector, where the FFT is evaluated in place. + Imaginary part of the sample vector, where the FFT is evaluated in place. + Fourier Transform Convention Options. + + + + Packed Real-Complex forward Fast Fourier Transform (FFT) to arbitrary-length sample vectors. + Since for real-valued time samples the complex spectrum is conjugate-even (symmetry), + the spectrum can be fully reconstructed from the positive frequencies only (first half). + The data array needs to be N+2 (if N is even) or N+1 (if N is odd) long in order to support such a packed spectrum. + + Data array of length N+2 (if N is even) or N+1 (if N is odd). + The number of samples. + Fourier Transform Convention Options. + + + + Packed Real-Complex forward Fast Fourier Transform (FFT) to arbitrary-length sample vectors. + Since for real-valued time samples the complex spectrum is conjugate-even (symmetry), + the spectrum can be fully reconstructed form the positive frequencies only (first half). + The data array needs to be N+2 (if N is even) or N+1 (if N is odd) long in order to support such a packed spectrum. + + Data array of length N+2 (if N is even) or N+1 (if N is odd). + The number of samples. + Fourier Transform Convention Options. + + + + Applies the forward Fast Fourier Transform (FFT) to multiple dimensional sample data. + + Sample data, where the FFT is evaluated in place. + + The data size per dimension. The first dimension is the major one. + For example, with two dimensions "rows" and "columns" the samples are assumed to be organized row by row. + + Fourier Transform Convention Options. + + + + Applies the forward Fast Fourier Transform (FFT) to multiple dimensional sample data. + + Sample data, where the FFT is evaluated in place. + + The data size per dimension. The first dimension is the major one. + For example, with two dimensions "rows" and "columns" the samples are assumed to be organized row by row. + + Fourier Transform Convention Options. + + + + Applies the forward Fast Fourier Transform (FFT) to two dimensional sample data. + + Sample data, organized row by row, where the FFT is evaluated in place + The number of rows. + The number of columns. + Data available organized column by column instead of row by row can be processed directly by swapping the rows and columns arguments. + Fourier Transform Convention Options. + + + + Applies the forward Fast Fourier Transform (FFT) to two dimensional sample data. + + Sample data, organized row by row, where the FFT is evaluated in place + The number of rows. + The number of columns. + Data available organized column by column instead of row by row can be processed directly by swapping the rows and columns arguments. + Fourier Transform Convention Options. + + + + Applies the forward Fast Fourier Transform (FFT) to a two dimensional data in form of a matrix. + + Sample matrix, where the FFT is evaluated in place + Fourier Transform Convention Options. + + + + Applies the forward Fast Fourier Transform (FFT) to a two dimensional data in form of a matrix. + + Sample matrix, where the FFT is evaluated in place + Fourier Transform Convention Options. + + + + Applies the inverse Fast Fourier Transform (iFFT) to arbitrary-length sample vectors. + + Spectrum data, where the iFFT is evaluated in place. + + + + Applies the inverse Fast Fourier Transform (iFFT) to arbitrary-length sample vectors. + + Spectrum data, where the iFFT is evaluated in place. + + + + Applies the inverse Fast Fourier Transform (iFFT) to arbitrary-length sample vectors. + + Spectrum data, where the iFFT is evaluated in place. + Fourier Transform Convention Options. + + + + Applies the inverse Fast Fourier Transform (iFFT) to arbitrary-length sample vectors. + + Spectrum data, where the iFFT is evaluated in place. + Fourier Transform Convention Options. + + + + Applies the inverse Fast Fourier Transform (iFFT) to arbitrary-length sample vectors. + + Real part of the sample vector, where the iFFT is evaluated in place. + Imaginary part of the sample vector, where the iFFT is evaluated in place. + Fourier Transform Convention Options. + + + + Applies the inverse Fast Fourier Transform (iFFT) to arbitrary-length sample vectors. + + Real part of the sample vector, where the iFFT is evaluated in place. + Imaginary part of the sample vector, where the iFFT is evaluated in place. + Fourier Transform Convention Options. + + + + Packed Real-Complex inverse Fast Fourier Transform (iFFT) to arbitrary-length sample vectors. + Since for real-valued time samples the complex spectrum is conjugate-even (symmetry), + the spectrum can be fully reconstructed form the positive frequencies only (first half). + The data array needs to be N+2 (if N is even) or N+1 (if N is odd) long in order to support such a packed spectrum. + + Data array of length N+2 (if N is even) or N+1 (if N is odd). + The number of samples. + Fourier Transform Convention Options. + + + + Packed Real-Complex inverse Fast Fourier Transform (iFFT) to arbitrary-length sample vectors. + Since for real-valued time samples the complex spectrum is conjugate-even (symmetry), + the spectrum can be fully reconstructed form the positive frequencies only (first half). + The data array needs to be N+2 (if N is even) or N+1 (if N is odd) long in order to support such a packed spectrum. + + Data array of length N+2 (if N is even) or N+1 (if N is odd). + The number of samples. + Fourier Transform Convention Options. + + + + Applies the inverse Fast Fourier Transform (iFFT) to multiple dimensional sample data. + + Spectrum data, where the iFFT is evaluated in place. + + The data size per dimension. The first dimension is the major one. + For example, with two dimensions "rows" and "columns" the samples are assumed to be organized row by row. + + Fourier Transform Convention Options. + + + + Applies the inverse Fast Fourier Transform (iFFT) to multiple dimensional sample data. + + Spectrum data, where the iFFT is evaluated in place. + + The data size per dimension. The first dimension is the major one. + For example, with two dimensions "rows" and "columns" the samples are assumed to be organized row by row. + + Fourier Transform Convention Options. + + + + Applies the inverse Fast Fourier Transform (iFFT) to two dimensional sample data. + + Sample data, organized row by row, where the iFFT is evaluated in place + The number of rows. + The number of columns. + Data available organized column by column instead of row by row can be processed directly by swapping the rows and columns arguments. + Fourier Transform Convention Options. + + + + Applies the inverse Fast Fourier Transform (iFFT) to two dimensional sample data. + + Sample data, organized row by row, where the iFFT is evaluated in place + The number of rows. + The number of columns. + Data available organized column by column instead of row by row can be processed directly by swapping the rows and columns arguments. + Fourier Transform Convention Options. + + + + Applies the inverse Fast Fourier Transform (iFFT) to a two dimensional data in form of a matrix. + + Sample matrix, where the iFFT is evaluated in place + Fourier Transform Convention Options. + + + + Applies the inverse Fast Fourier Transform (iFFT) to a two dimensional data in form of a matrix. + + Sample matrix, where the iFFT is evaluated in place + Fourier Transform Convention Options. + + + + Generate the frequencies corresponding to each index in frequency space. + The frequency space has a resolution of sampleRate/N. + Index 0 corresponds to the DC part, the following indices correspond to + the positive frequencies up to the Nyquist frequency (sampleRate/2), + followed by the negative frequencies wrapped around. + + Number of samples. + The sampling rate of the time-space data. + + + + Fourier Transform Convention + + + + + Inverse integrand exponent (forward: positive sign; inverse: negative sign). + + + + + Only scale by 1/N in the inverse direction; No scaling in forward direction. + + + + + Don't scale at all (neither on forward nor on inverse transformation). + + + + + Universal; Symmetric scaling and common exponent (used in Maple). + + + + + Only scale by 1/N in the inverse direction; No scaling in forward direction (used in Matlab). [= AsymmetricScaling] + + + + + Inverse integrand exponent; No scaling at all (used in all Numerical Recipes based implementations). [= InverseExponent | NoScaling] + + + + + Fast (FHT) Implementation of the Discrete Hartley Transform (DHT). + + + Fast (FHT) Implementation of the Discrete Hartley Transform (DHT). + + + + + Naive forward DHT, useful e.g. to verify faster algorithms. + + Time-space sample vector. + Hartley Transform Convention Options. + Corresponding frequency-space vector. + + + + Naive inverse DHT, useful e.g. to verify faster algorithms. + + Frequency-space sample vector. + Hartley Transform Convention Options. + Corresponding time-space vector. + + + + Rescale FFT-the resulting vector according to the provided convention options. + + Fourier Transform Convention Options. + Sample Vector. + + + + Rescale the iFFT-resulting vector according to the provided convention options. + + Fourier Transform Convention Options. + Sample Vector. + + + + Naive generic DHT, useful e.g. to verify faster algorithms. + + Time-space sample vector. + Corresponding frequency-space vector. + + + + Hartley Transform Convention + + + + + Only scale by 1/N in the inverse direction; No scaling in forward direction. + + + + + Don't scale at all (neither on forward nor on inverse transformation). + + + + + Universal; Symmetric scaling. + + + + + Numerical Integration (Quadrature). + + + + + Approximation of the definite integral of an analytic smooth function on a closed interval. + + The analytic smooth function to integrate. + Where the interval starts, inclusive and finite. + Where the interval stops, inclusive and finite. + The expected relative accuracy of the approximation. + Approximation of the finite integral in the given interval. + + + + Approximation of the definite integral of an analytic smooth function on a closed interval. + + The analytic smooth function to integrate. + Where the interval starts, inclusive and finite. + Where the interval stops, inclusive and finite. + Approximation of the finite integral in the given interval. + + + + Approximates a 2-dimensional definite integral using an Nth order Gauss-Legendre rule over the rectangle [a,b] x [c,d]. + + The 2-dimensional analytic smooth function to integrate. + Where the interval starts for the first (inside) integral, exclusive and finite. + Where the interval ends for the first (inside) integral, exclusive and finite. + Where the interval starts for the second (outside) integral, exclusive and finite. + /// Where the interval ends for the second (outside) integral, exclusive and finite. + Defines an Nth order Gauss-Legendre rule. The order also defines the number of abscissas and weights for the rule. Precomputed Gauss-Legendre abscissas/weights for orders 2-20, 32, 64, 96, 100, 128, 256, 512, 1024 are used, otherwise they're calculated on the fly. + Approximation of the finite integral in the given interval. + + + + Approximates a 2-dimensional definite integral using an Nth order Gauss-Legendre rule over the rectangle [a,b] x [c,d]. + + The 2-dimensional analytic smooth function to integrate. + Where the interval starts for the first (inside) integral, exclusive and finite. + Where the interval ends for the first (inside) integral, exclusive and finite. + Where the interval starts for the second (outside) integral, exclusive and finite. + /// Where the interval ends for the second (outside) integral, exclusive and finite. + Approximation of the finite integral in the given interval. + + + + Approximation of the definite integral of an analytic smooth function by double-exponential quadrature. When either or both limits are infinite, the integrand is assumed rapidly decayed to zero as x -> infinity. + + The analytic smooth function to integrate. + Where the interval starts. + Where the interval stops. + The expected relative accuracy of the approximation. + Approximation of the finite integral in the given interval. + + + + Approximation of the definite integral of an analytic smooth function by Gauss-Legendre quadrature. When either or both limits are infinite, the integrand is assumed rapidly decayed to zero as x -> infinity. + + The analytic smooth function to integrate. + Where the interval starts. + Where the interval stops. + Defines an Nth order Gauss-Legendre rule. The order also defines the number of abscissas and weights for the rule. Precomputed Gauss-Legendre abscissas/weights for orders 2-20, 32, 64, 96, 100, 128, 256, 512, 1024 are used, otherwise they're calculated on the fly. + Approximation of the finite integral in the given interval. + + + + Approximation of the definite integral of an analytic smooth function by Gauss-Kronrod quadrature. When either or both limits are infinite, the integrand is assumed rapidly decayed to zero as x -> infinity. + + The analytic smooth function to integrate. + Where the interval starts. + Where the interval stops. + The expected relative accuracy of the approximation. + The maximum number of interval splittings permitted before stopping. + The number of Gauss-Kronrod points. Pre-computed for 15, 21, 31, 41, 51 and 61 points. + Approximation of the finite integral in the given interval. + + + + Approximation of the definite integral of an analytic smooth function by Gauss-Kronrod quadrature. When either or both limits are infinite, the integrand is assumed rapidly decayed to zero as x -> infinity. + + The analytic smooth function to integrate. + Where the interval starts. + Where the interval stops. + The difference between the (N-1)/2 point Gauss approximation and the N-point Gauss-Kronrod approximation + The L1 norm of the result, if there is a significant difference between this and the returned value, then the result is likely to be ill-conditioned. + The expected relative accuracy of the approximation. + The maximum number of interval splittings permitted before stopping + The number of Gauss-Kronrod points. Pre-computed for 15, 21, 31, 41, 51 and 61 points + Approximation of the finite integral in the given interval. + + + + Numerical Contour Integration of a complex-valued function over a real variable,. + + + + + Approximation of the definite integral of an analytic smooth complex function by double-exponential quadrature. When either or both limits are infinite, the integrand is assumed rapidly decayed to zero as x -> infinity. + + The analytic smooth complex function to integrate, defined on the real domain. + Where the interval starts. + Where the interval stops. + The expected relative accuracy of the approximation. + Approximation of the finite integral in the given interval. + + + + Approximation of the definite integral of an analytic smooth complex function by double-exponential quadrature. When either or both limits are infinite, the integrand is assumed rapidly decayed to zero as x -> infinity. + + The analytic smooth complex function to integrate, defined on the real domain. + Where the interval starts. + Where the interval stops. + Defines an Nth order Gauss-Legendre rule. The order also defines the number of abscissas and weights for the rule. Precomputed Gauss-Legendre abscissas/weights for orders 2-20, 32, 64, 96, 100, 128, 256, 512, 1024 are used, otherwise they're calculated on the fly. + Approximation of the finite integral in the given interval. + + + + Approximation of the definite integral of an analytic smooth function by Gauss-Kronrod quadrature. When either or both limits are infinite, the integrand is assumed rapidly decayed to zero as x -> infinity. + + The analytic smooth complex function to integrate, defined on the real domain. + Where the interval starts. + Where the interval stops. + The expected relative accuracy of the approximation. + The maximum number of interval splittings permitted before stopping + The number of Gauss-Kronrod points. Pre-computed for 15, 21, 31, 41, 51 and 61 points + Approximation of the finite integral in the given interval. + + + + Approximation of the definite integral of an analytic smooth function by Gauss-Kronrod quadrature. When either or both limits are infinite, the integrand is assumed rapidly decayed to zero as x -> infinity. + + The analytic smooth complex function to integrate, defined on the real domain. + Where the interval starts. + Where the interval stops. + The difference between the (N-1)/2 point Gauss approximation and the N-point Gauss-Kronrod approximation + The L1 norm of the result, if there is a significant difference between this and the returned value, then the result is likely to be ill-conditioned. + The expected relative accuracy of the approximation. + The maximum number of interval splittings permitted before stopping + The number of Gauss-Kronrod points. Pre-computed for 15, 21, 31, 41, 51 and 61 points + Approximation of the finite integral in the given interval. + + + + Analytic integration algorithm for smooth functions with no discontinuities + or derivative discontinuities and no poles inside the interval. + + + + + Maximum number of iterations, until the asked + maximum error is (likely to be) satisfied. + + + + + Approximate the integral by the double exponential transformation + + The analytic smooth function to integrate. + Where the interval starts, inclusive and finite. + Where the interval stops, inclusive and finite. + The expected relative accuracy of the approximation. + Approximation of the finite integral in the given interval. + + + + Approximate the integral by the double exponential transformation + + The analytic smooth complex function to integrate, defined on the real domain. + Where the interval starts, inclusive and finite. + Where the interval stops, inclusive and finite. + The expected relative accuracy of the approximation. + Approximation of the finite integral in the given interval. + + + + Compute the abscissa vector for a single level. + + The level to evaluate the abscissa vector for. + Abscissa Vector. + + + + Compute the weight vector for a single level. + + The level to evaluate the weight vector for. + Weight Vector. + + + + Precomputed abscissa vector per level. + + + + + Precomputed weight vector per level. + + + + + Getter for the order. + + + + + Getter that returns a clone of the array containing the Kronrod abscissas. + + + + + Getter that returns a clone of the array containing the Kronrod weights. + + + + + Getter that returns a clone of the array containing the Gauss weights. + + + + + Performs adaptive Gauss-Kronrod quadrature on function f over the range (a,b) + + The analytic smooth function to integrate + Where the interval starts + Where the interval stops + The difference between the (N-1)/2 point Gauss approximation and the N-point Gauss-Kronrod approximation + The L1 norm of the result, if there is a significant difference between this and the returned value, then the result is likely to be ill-conditioned. + The maximum relative error in the result + The maximum number of interval splittings permitted before stopping + The number of Gauss-Kronrod points. Pre-computed for 15, 21, 31, 41, 51 and 61 points + + + + Performs adaptive Gauss-Kronrod quadrature on function f over the range (a,b) + + The analytic smooth complex function to integrate, defined on the real axis. + Where the interval starts + Where the interval stops + The difference between the (N-1)/2 point Gauss approximation and the N-point Gauss-Kronrod approximation + The L1 norm of the result, if there is a significant difference between this and the returned value, then the result is likely to be ill-conditioned. + The maximum relative error in the result + The maximum number of interval splittings permitted before stopping + The number of Gauss-Kronrod points. Pre-computed for 15, 21, 31, 41, 51 and 61 points + + + + + Approximates a definite integral using an Nth order Gauss-Legendre rule. Precomputed Gauss-Legendre abscissas/weights for orders 2-20, 32, 64, 96, 100, 128, 256, 512, 1024 are used, otherwise they're calculated on the fly. + + + + + Initializes a new instance of the class. + + Where the interval starts, inclusive and finite. + Where the interval stops, inclusive and finite. + Defines an Nth order Gauss-Legendre rule. The order also defines the number of abscissas and weights for the rule. Precomputed Gauss-Legendre abscissas/weights for orders 2-20, 32, 64, 96, 100, 128, 256, 512, 1024 are used, otherwise they're calculated on the fly. + + + + Gettter for the ith abscissa. + + Index of the ith abscissa. + The ith abscissa. + + + + Getter that returns a clone of the array containing the abscissas. + + + + + Getter for the ith weight. + + Index of the ith weight. + The ith weight. + + + + Getter that returns a clone of the array containing the weights. + + + + + Getter for the order. + + + + + Getter for the InvervalBegin. + + + + + Getter for the InvervalEnd. + + + + + Approximates a definite integral using an Nth order Gauss-Legendre rule. + + The analytic smooth function to integrate. + Where the interval starts, exclusive and finite. + Where the interval ends, exclusive and finite. + Defines an Nth order Gauss-Legendre rule. The order also defines the number of abscissas and weights for the rule. Precomputed Gauss-Legendre abscissas/weights for orders 2-20, 32, 64, 96, 100, 128, 256, 512, 1024 are used, otherwise they're calculated on the fly. + Approximation of the finite integral in the given interval. + + + + Approximates a definite integral using an Nth order Gauss-Legendre rule. + + The analytic smooth complex function to integrate, defined on the real domain. + Where the interval starts, exclusive and finite. + Where the interval ends, exclusive and finite. + Defines an Nth order Gauss-Legendre rule. The order also defines the number of abscissas and weights for the rule. Precomputed Gauss-Legendre abscissas/weights for orders 2-20, 32, 64, 96, 100, 128, 256, 512, 1024 are used, otherwise they're calculated on the fly. + Approximation of the finite integral in the given interval. + + + + Approximates a 2-dimensional definite integral using an Nth order Gauss-Legendre rule over the rectangle [a,b] x [c,d]. + + The 2-dimensional analytic smooth function to integrate. + Where the interval starts for the first (inside) integral, exclusive and finite. + Where the interval ends for the first (inside) integral, exclusive and finite. + Where the interval starts for the second (outside) integral, exclusive and finite. + /// Where the interval ends for the second (outside) integral, exclusive and finite. + Defines an Nth order Gauss-Legendre rule. The order also defines the number of abscissas and weights for the rule. Precomputed Gauss-Legendre abscissas/weights for orders 2-20, 32, 64, 96, 100, 128, 256, 512, 1024 are used, otherwise they're calculated on the fly. + Approximation of the finite integral in the given interval. + + + + Contains a method to compute the Gauss-Kronrod abscissas/weights and precomputed abscissas/weights for orders 15, 21, 31, 41, 51, 61. + + + Contains a method to compute the Gauss-Kronrod abscissas/weights. + + + + + Precomputed abscissas/weights for orders 15, 21, 31, 41, 51, 61. + + + + + Computes the Gauss-Kronrod abscissas/weights and Gauss weights. + + Defines an Nth order Gauss-Kronrod rule. The order also defines the number of abscissas and weights for the rule. + Required precision to compute the abscissas/weights. + Object containing the non-negative abscissas/weights, order. + + + + Returns coefficients of a Stieltjes polynomial in terms of Legendre polynomials. + + + + + Return value and derivative of a Legendre series at given points. + + + + + Return value and derivative of a Legendre polynomial of order at given points. + + + + + Creates a Gauss-Kronrod point. + + + + + Getter for the GaussKronrodPoint. + + Defines an Nth order Gauss-Kronrod rule. Precomputed Gauss-Kronrod abscissas/weights for orders 15, 21, 31, 41, 51, 61 are used, otherwise they're calculated on the fly. + Object containing the non-negative abscissas/weights, and order. + + + + Contains a method to compute the Gauss-Legendre abscissas/weights and precomputed abscissas/weights for orders 2-20, 32, 64, 96, 100, 128, 256, 512, 1024. + + + Contains a method to compute the Gauss-Legendre abscissas/weights and precomputed abscissas/weights for orders 2-20, 32, 64, 96, 100, 128, 256, 512, 1024. + + + + + Precomputed abscissas/weights for orders 2-20, 32, 64, 96, 100, 128, 256, 512, 1024. + + + + + Computes the Gauss-Legendre abscissas/weights. + See Pavel Holoborodko for a description of the algorithm. + + Defines an Nth order Gauss-Legendre rule. The order also defines the number of abscissas and weights for the rule. + Required precision to compute the abscissas/weights. 1e-10 is usually fine. + Object containing the non-negative abscissas/weights, order, and intervalBegin/intervalEnd. The non-negative abscissas/weights are generated over the interval [-1,1] for the given order. + + + + Creates and maps a Gauss-Legendre point. + + + + + Getter for the GaussPoint. + + Defines an Nth order Gauss-Legendre rule. Precomputed Gauss-Legendre abscissas/weights for orders 2-20, 32, 64, 96, 100, 128, 256, 512, 1024 are used, otherwise they're calculated on the fly. + Object containing the non-negative abscissas/weights, order, and intervalBegin/intervalEnd. The non-negative abscissas/weights are generated over the interval [-1,1] for the given order. + + + + Getter for the GaussPoint. + + Where the interval starts, inclusive and finite. + Where the interval stops, inclusive and finite. + Defines an Nth order Gauss-Legendre rule. Precomputed Gauss-Legendre abscissas/weights for orders 2-20, 32, 64, 96, 100, 128, 256, 512, 1024 are used, otherwise they're calculated on the fly. + Object containing the abscissas/weights, order, and intervalBegin/intervalEnd. + + + + Maps the non-negative abscissas/weights from the interval [-1, 1] to the interval [intervalBegin, intervalEnd]. + + Where the interval starts, inclusive and finite. + Where the interval stops, inclusive and finite. + Object containing the non-negative abscissas/weights, order, and intervalBegin/intervalEnd. The non-negative abscissas/weights are generated over the interval [-1,1] for the given order. + Object containing the abscissas/weights, order, and intervalBegin/intervalEnd. + + + + Contains the abscissas/weights, order, and intervalBegin/intervalEnd. + + + + + Contains two GaussPoint. + + + + + Approximation algorithm for definite integrals by the Trapezium rule of the Newton-Cotes family. + + + Wikipedia - Trapezium Rule + + + + + Direct 2-point approximation of the definite integral in the provided interval by the trapezium rule. + + The analytic smooth function to integrate. + Where the interval starts, inclusive and finite. + Where the interval stops, inclusive and finite. + Approximation of the finite integral in the given interval. + + + + Direct 2-point approximation of the definite integral in the provided interval by the trapezium rule. + + The analytic smooth complex function to integrate, defined on real domain. + Where the interval starts, inclusive and finite. + Where the interval stops, inclusive and finite. + Approximation of the finite integral in the given interval. + + + + Composite N-point approximation of the definite integral in the provided interval by the trapezium rule. + + The analytic smooth function to integrate. + Where the interval starts, inclusive and finite. + Where the interval stops, inclusive and finite. + Number of composite subdivision partitions. + Approximation of the finite integral in the given interval. + + + + Composite N-point approximation of the definite integral in the provided interval by the trapezium rule. + + The analytic smooth complex function to integrate, defined on real domain. + Where the interval starts, inclusive and finite. + Where the interval stops, inclusive and finite. + Number of composite subdivision partitions. + Approximation of the finite integral in the given interval. + + + + Adaptive approximation of the definite integral in the provided interval by the trapezium rule. + + The analytic smooth function to integrate. + Where the interval starts, inclusive and finite. + Where the interval stops, inclusive and finite. + The expected accuracy of the approximation. + Approximation of the finite integral in the given interval. + + + + Adaptive approximation of the definite integral in the provided interval by the trapezium rule. + + The analytic smooth complex function to integrate, define don real domain. + Where the interval starts, inclusive and finite. + Where the interval stops, inclusive and finite. + The expected accuracy of the approximation. + Approximation of the finite integral in the given interval. + + + + Adaptive approximation of the definite integral by the trapezium rule. + + The analytic smooth function to integrate. + Where the interval starts, inclusive and finite. + Where the interval stops, inclusive and finite. + Abscissa vector per level provider. + Weight vector per level provider. + First Level Step + The expected relative accuracy of the approximation. + Approximation of the finite integral in the given interval. + + + + Adaptive approximation of the definite integral by the trapezium rule. + + The analytic smooth complex function to integrate, defined on the real domain. + Where the interval starts, inclusive and finite. + Where the interval stops, inclusive and finite. + Abscissa vector per level provider. + Weight vector per level provider. + First Level Step + The expected relative accuracy of the approximation. + Approximation of the finite integral in the given interval. + + + + Approximation algorithm for definite integrals by Simpson's rule. + + + + + Direct 3-point approximation of the definite integral in the provided interval by Simpson's rule. + + The analytic smooth function to integrate. + Where the interval starts, inclusive and finite. + Where the interval stops, inclusive and finite. + Approximation of the finite integral in the given interval. + + + + Composite N-point approximation of the definite integral in the provided interval by Simpson's rule. + + The analytic smooth function to integrate. + Where the interval starts, inclusive and finite. + Where the interval stops, inclusive and finite. + Even number of composite subdivision partitions. + Approximation of the finite integral in the given interval. + + + + Interpolation Factory. + + + + + Creates an interpolation based on arbitrary points. + + The sample points t. + The sample point values x(t). + + An interpolation scheme optimized for the given sample points and values, + which can then be used to compute interpolations and extrapolations + on arbitrary points. + + + if your data is already sorted in arrays, consider to use + MathNet.Numerics.Interpolation.Barycentric.InterpolateRationalFloaterHormannSorted + instead, which is more efficient. + + + + + Create a Floater-Hormann rational pole-free interpolation based on arbitrary points. + + The sample points t. + The sample point values x(t). + + An interpolation scheme optimized for the given sample points and values, + which can then be used to compute interpolations and extrapolations + on arbitrary points. + + + if your data is already sorted in arrays, consider to use + MathNet.Numerics.Interpolation.Barycentric.InterpolateRationalFloaterHormannSorted + instead, which is more efficient. + + + + + Create a Bulirsch Stoer rational interpolation based on arbitrary points. + + The sample points t. + The sample point values x(t). + + An interpolation scheme optimized for the given sample points and values, + which can then be used to compute interpolations and extrapolations + on arbitrary points. + + + if your data is already sorted in arrays, consider to use + MathNet.Numerics.Interpolation.BulirschStoerRationalInterpolation.InterpolateSorted + instead, which is more efficient. + + + + + Create a barycentric polynomial interpolation where the given sample points are equidistant. + + The sample points t, must be equidistant. + The sample point values x(t). + + An interpolation scheme optimized for the given sample points and values, + which can then be used to compute interpolations and extrapolations + on arbitrary points. + + + if your data is already sorted in arrays, consider to use + MathNet.Numerics.Interpolation.Barycentric.InterpolatePolynomialEquidistantSorted + instead, which is more efficient. + + + + + Create a Neville polynomial interpolation based on arbitrary points. + If the points happen to be equidistant, consider to use the much more robust PolynomialEquidistant instead. + Otherwise, consider whether RationalWithoutPoles would not be a more robust alternative. + + The sample points t. + The sample point values x(t). + + An interpolation scheme optimized for the given sample points and values, + which can then be used to compute interpolations and extrapolations + on arbitrary points. + + + if your data is already sorted in arrays, consider to use + MathNet.Numerics.Interpolation.NevillePolynomialInterpolation.InterpolateSorted + instead, which is more efficient. + + + + + Create a piecewise linear interpolation based on arbitrary points. + + The sample points t. + The sample point values x(t). + + An interpolation scheme optimized for the given sample points and values, + which can then be used to compute interpolations and extrapolations + on arbitrary points. + + + if your data is already sorted in arrays, consider to use + MathNet.Numerics.Interpolation.LinearSpline.InterpolateSorted + instead, which is more efficient. + + + + + Create piecewise log-linear interpolation based on arbitrary points. + + The sample points t. + The sample point values x(t). + + An interpolation scheme optimized for the given sample points and values, + which can then be used to compute interpolations and extrapolations + on arbitrary points. + + + if your data is already sorted in arrays, consider to use + MathNet.Numerics.Interpolation.LogLinear.InterpolateSorted + instead, which is more efficient. + + + + + Create an piecewise natural cubic spline interpolation based on arbitrary points, + with zero secondary derivatives at the boundaries. + + The sample points t. + The sample point values x(t). + + An interpolation scheme optimized for the given sample points and values, + which can then be used to compute interpolations and extrapolations + on arbitrary points. + + + if your data is already sorted in arrays, consider to use + MathNet.Numerics.Interpolation.CubicSpline.InterpolateNaturalSorted + instead, which is more efficient. + + + + + Create a piecewise cubic Akima spline interpolation based on arbitrary points. + Akima splines are robust to outliers. + + The sample points t. + The sample point values x(t). + + An interpolation scheme optimized for the given sample points and values, + which can then be used to compute interpolations and extrapolations + on arbitrary points. + + + if your data is already sorted in arrays, consider to use + MathNet.Numerics.Interpolation.CubicSpline.InterpolateAkimaSorted + instead, which is more efficient. + + + + + Create a piecewise cubic monotone spline interpolation based on arbitrary points. + This is a shape-preserving spline with continuous first derivative. + + The sample points t. + The sample point values x(t). + + An interpolation scheme optimized for the given sample points and values, + which can then be used to compute interpolations and extrapolations + on arbitrary points. + + + if your data is already sorted in arrays, consider to use + MathNet.Numerics.Interpolation.CubicSpline.InterpolatePchipSorted + instead, which is more efficient. + + + + + Create a piecewise cubic Hermite spline interpolation based on arbitrary points + and their slopes/first derivative. + + The sample points t. + The sample point values x(t). + The slope at the sample points. Optimized for arrays. + + An interpolation scheme optimized for the given sample points and values, + which can then be used to compute interpolations and extrapolations + on arbitrary points. + + + if your data is already sorted in arrays, consider to use + MathNet.Numerics.Interpolation.CubicSpline.InterpolateHermiteSorted + instead, which is more efficient. + + + + + Create a step-interpolation based on arbitrary points. + + The sample points t. + The sample point values x(t). + + An interpolation scheme optimized for the given sample points and values, + which can then be used to compute interpolations and extrapolations + on arbitrary points. + + + if your data is already sorted in arrays, consider to use + MathNet.Numerics.Interpolation.StepInterpolation.InterpolateSorted + instead, which is more efficient. + + + + + Barycentric Interpolation Algorithm. + + Supports neither differentiation nor integration. + + + Sample points (N), sorted ascendingly. + Sample values (N), sorted ascendingly by x. + Barycentric weights (N), sorted ascendingly by x. + + + + Create a barycentric polynomial interpolation from a set of (x,y) value pairs with equidistant x, sorted ascendingly by x. + + + + + Create a barycentric polynomial interpolation from an unordered set of (x,y) value pairs with equidistant x. + WARNING: Works in-place and can thus causes the data array to be reordered. + + + + + Create a barycentric polynomial interpolation from an unsorted set of (x,y) value pairs with equidistant x. + + + + + Create a barycentric polynomial interpolation from a set of values related to linearly/equidistant spaced points within an interval. + + + + + Create a barycentric rational interpolation without poles, using Mike Floater and Kai Hormann's Algorithm. + The values are assumed to be sorted ascendingly by x. + + Sample points (N), sorted ascendingly. + Sample values (N), sorted ascendingly by x. + + Order of the interpolation scheme, 0 <= order <= N. + In most cases a value between 3 and 8 gives good results. + + + + + Create a barycentric rational interpolation without poles, using Mike Floater and Kai Hormann's Algorithm. + WARNING: Works in-place and can thus causes the data array to be reordered. + + Sample points (N), no sorting assumed. + Sample values (N). + + Order of the interpolation scheme, 0 <= order <= N. + In most cases a value between 3 and 8 gives good results. + + + + + Create a barycentric rational interpolation without poles, using Mike Floater and Kai Hormann's Algorithm. + + Sample points (N), no sorting assumed. + Sample values (N). + + Order of the interpolation scheme, 0 <= order <= N. + In most cases a value between 3 and 8 gives good results. + + + + + Create a barycentric rational interpolation without poles, using Mike Floater and Kai Hormann's Algorithm. + The values are assumed to be sorted ascendingly by x. + + Sample points (N), sorted ascendingly. + Sample values (N), sorted ascendingly by x. + + + + Create a barycentric rational interpolation without poles, using Mike Floater and Kai Hormann's Algorithm. + WARNING: Works in-place and can thus causes the data array to be reordered. + + Sample points (N), no sorting assumed. + Sample values (N). + + + + Create a barycentric rational interpolation without poles, using Mike Floater and Kai Hormann's Algorithm. + + Sample points (N), no sorting assumed. + Sample values (N). + + + + Gets a value indicating whether the algorithm supports differentiation (interpolated derivative). + + + + + Gets a value indicating whether the algorithm supports integration (interpolated quadrature). + + + + + Interpolate at point t. + + Point t to interpolate at. + Interpolated value x(t). + + + + Differentiate at point t. NOT SUPPORTED. + + Point t to interpolate at. + Interpolated first derivative at point t. + + + + Differentiate twice at point t. NOT SUPPORTED. + + Point t to interpolate at. + Interpolated second derivative at point t. + + + + Indefinite integral at point t. NOT SUPPORTED. + + Point t to integrate at. + + + + Definite integral between points a and b. NOT SUPPORTED. + + Left bound of the integration interval [a,b]. + Right bound of the integration interval [a,b]. + + + + Rational Interpolation (with poles) using Roland Bulirsch and Josef Stoer's Algorithm. + + + + This algorithm supports neither differentiation nor integration. + + + + + Sample Points t, sorted ascendingly. + Sample Values x(t), sorted ascendingly by x. + + + + Create a Bulirsch-Stoer rational interpolation from a set of (x,y) value pairs, sorted ascendingly by x. + + + + + Create a Bulirsch-Stoer rational interpolation from an unsorted set of (x,y) value pairs. + WARNING: Works in-place and can thus causes the data array to be reordered. + + + + + Create a Bulirsch-Stoer rational interpolation from an unsorted set of (x,y) value pairs. + + + + + Gets a value indicating whether the algorithm supports differentiation (interpolated derivative). + + + + + Gets a value indicating whether the algorithm supports integration (interpolated quadrature). + + + + + Interpolate at point t. + + Point t to interpolate at. + Interpolated value x(t). + + + + Differentiate at point t. NOT SUPPORTED. + + Point t to interpolate at. + Interpolated first derivative at point t. + + + + Differentiate twice at point t. NOT SUPPORTED. + + Point t to interpolate at. + Interpolated second derivative at point t. + + + + Indefinite integral at point t. NOT SUPPORTED. + + Point t to integrate at. + + + + Definite integral between points a and b. NOT SUPPORTED. + + Left bound of the integration interval [a,b]. + Right bound of the integration interval [a,b]. + + + + Cubic Spline Interpolation. + + Supports both differentiation and integration. + + + sample points (N+1), sorted ascending + Zero order spline coefficients (N) + First order spline coefficients (N) + second order spline coefficients (N) + third order spline coefficients (N) + + + + Create a Hermite cubic spline interpolation from a set of (x,y) value pairs and their slope (first derivative), sorted ascendingly by x. + + + + + Create a Hermite cubic spline interpolation from an unsorted set of (x,y) value pairs and their slope (first derivative). + WARNING: Works in-place and can thus causes the data array to be reordered. + + + + + Create a Hermite cubic spline interpolation from an unsorted set of (x,y) value pairs and their slope (first derivative). + + + + + Create an Akima cubic spline interpolation from a set of (x,y) value pairs, sorted ascendingly by x. + Akima splines are robust to outliers. + + + + + Create an Akima cubic spline interpolation from an unsorted set of (x,y) value pairs. + Akima splines are robust to outliers. + WARNING: Works in-place and can thus causes the data array to be reordered. + + + + + Create an Akima cubic spline interpolation from an unsorted set of (x,y) value pairs. + Akima splines are robust to outliers. + + + + + Create a piecewise cubic Hermite interpolating polynomial from an unsorted set of (x,y) value pairs. + Monotone-preserving interpolation with continuous first derivative. + + + + + Create a piecewise cubic Hermite interpolating polynomial from an unsorted set of (x,y) value pairs. + Monotone-preserving interpolation with continuous first derivative. + WARNING: Works in-place and can thus causes the data array to be reordered. + + + + + Create a piecewise cubic Hermite interpolating polynomial from an unsorted set of (x,y) value pairs. + Monotone-preserving interpolation with continuous first derivative. + + + + + Create a cubic spline interpolation from a set of (x,y) value pairs, sorted ascendingly by x, + and custom boundary/termination conditions. + + + + + Create a cubic spline interpolation from an unsorted set of (x,y) value pairs and custom boundary/termination conditions. + WARNING: Works in-place and can thus causes the data array to be reordered. + + + + + Create a cubic spline interpolation from an unsorted set of (x,y) value pairs and custom boundary/termination conditions. + + + + + Create a natural cubic spline interpolation from a set of (x,y) value pairs + and zero second derivatives at the two boundaries, sorted ascendingly by x. + + + + + Create a natural cubic spline interpolation from an unsorted set of (x,y) value pairs + and zero second derivatives at the two boundaries. + WARNING: Works in-place and can thus causes the data array to be reordered. + + + + + Create a natural cubic spline interpolation from an unsorted set of (x,y) value pairs + and zero second derivatives at the two boundaries. + + + + + Three-Point Differentiation Helper. + + Sample Points t. + Sample Values x(t). + Index of the point of the differentiation. + Index of the first sample. + Index of the second sample. + Index of the third sample. + The derivative approximation. + + + + Tridiagonal Solve Helper. + + The a-vector[n]. + The b-vector[n], will be modified by this function. + The c-vector[n]. + The d-vector[n], will be modified by this function. + The x-vector[n] + + + + Gets a value indicating whether the algorithm supports differentiation (interpolated derivative). + + + + + Gets a value indicating whether the algorithm supports integration (interpolated quadrature). + + + + + Interpolate at point t. + + Point t to interpolate at. + Interpolated value x(t). + + + + Differentiate at point t. + + Point t to interpolate at. + Interpolated first derivative at point t. + + + + Differentiate twice at point t. + + Point t to interpolate at. + Interpolated second derivative at point t. + + + + Indefinite integral at point t. + + Point t to integrate at. + + + + Definite integral between points a and b. + + Left bound of the integration interval [a,b]. + Right bound of the integration interval [a,b]. + + + + Find the index of the greatest sample point smaller than t, + or the left index of the closest segment for extrapolation. + + + + + Gets all the t values where the derivative is 0 + see: https://mathworld.wolfram.com/StationaryPoint.html + + An array of t values (in the domain of the function) where the derivative of the spline is 0 + + + + Returns the t values in the domain of the spline for which it takes the minimum and maximum value. + + A tuple containing the t value for which the spline is minimum in the first component and maximum in the second component + + + + Interpolation within the range of a discrete set of known data points. + + + + + Gets a value indicating whether the algorithm supports differentiation (interpolated derivative). + + + + + Gets a value indicating whether the algorithm supports integration (interpolated quadrature). + + + + + Interpolate at point t. + + Point t to interpolate at. + Interpolated value x(t). + + + + Differentiate at point t. + + Point t to interpolate at. + Interpolated first derivative at point t. + + + + Differentiate twice at point t. + + Point t to interpolate at. + Interpolated second derivative at point t. + + + + Indefinite integral at point t. + + Point t to integrate at. + + + + Definite integral between points a and b. + + Left bound of the integration interval [a,b]. + Right bound of the integration interval [a,b]. + + + + Piece-wise Linear Interpolation. + + Supports both differentiation and integration. + + + Sample points (N+1), sorted ascending + Sample values (N or N+1) at the corresponding points; intercept, zero order coefficients + Slopes (N) at the sample points (first order coefficients): N + + + + Create a linear spline interpolation from a set of (x,y) value pairs, sorted ascendingly by x. + + + + + Create a linear spline interpolation from an unsorted set of (x,y) value pairs. + WARNING: Works in-place and can thus causes the data array to be reordered. + + + + + Create a linear spline interpolation from an unsorted set of (x,y) value pairs. + + + + + Gets a value indicating whether the algorithm supports differentiation (interpolated derivative). + + + + + Gets a value indicating whether the algorithm supports integration (interpolated quadrature). + + + + + Interpolate at point t. + + Point t to interpolate at. + Interpolated value x(t). + + + + Differentiate at point t. + + Point t to interpolate at. + Interpolated first derivative at point t. + + + + Differentiate twice at point t. + + Point t to interpolate at. + Interpolated second derivative at point t. + + + + Indefinite integral at point t. + + Point t to integrate at. + + + + Definite integral between points a and b. + + Left bound of the integration interval [a,b]. + Right bound of the integration interval [a,b]. + + + + Find the index of the greatest sample point smaller than t, + or the left index of the closest segment for extrapolation. + + + + + Piece-wise Log-Linear Interpolation + + This algorithm supports differentiation, not integration. + + + + Internal Spline Interpolation + + + + Sample points (N), sorted ascending + Natural logarithm of the sample values (N) at the corresponding points + + + + Create a piecewise log-linear interpolation from a set of (x,y) value pairs, sorted ascendingly by x. + + + + + Create a piecewise log-linear interpolation from an unsorted set of (x,y) value pairs. + WARNING: Works in-place and can thus causes the data array to be reordered and modified. + + + + + Create a piecewise log-linear interpolation from an unsorted set of (x,y) value pairs. + + + + + Gets a value indicating whether the algorithm supports differentiation (interpolated derivative). + + + + + Gets a value indicating whether the algorithm supports integration (interpolated quadrature). + + + + + Interpolate at point t. + + Point t to interpolate at. + Interpolated value x(t). + + + + Differentiate at point t. + + Point t to interpolate at. + Interpolated first derivative at point t. + + + + Differentiate twice at point t. + + Point t to interpolate at. + Interpolated second derivative at point t. + + + + Indefinite integral at point t. + + Point t to integrate at. + + + + Definite integral between points a and b. + + Left bound of the integration interval [a,b]. + Right bound of the integration interval [a,b]. + + + + Lagrange Polynomial Interpolation using Neville's Algorithm. + + + + This algorithm supports differentiation, but doesn't support integration. + + + When working with equidistant or Chebyshev sample points it is + recommended to use the barycentric algorithms specialized for + these cases instead of this arbitrary Neville algorithm. + + + + + Sample Points t, sorted ascendingly. + Sample Values x(t), sorted ascendingly by x. + + + + Create a Neville polynomial interpolation from a set of (x,y) value pairs, sorted ascendingly by x. + + + + + Create a Neville polynomial interpolation from an unsorted set of (x,y) value pairs. + WARNING: Works in-place and can thus causes the data array to be reordered. + + + + + Create a Neville polynomial interpolation from an unsorted set of (x,y) value pairs. + + + + + Gets a value indicating whether the algorithm supports differentiation (interpolated derivative). + + + + + Gets a value indicating whether the algorithm supports integration (interpolated quadrature). + + + + + Interpolate at point t. + + Point t to interpolate at. + Interpolated value x(t). + + + + Differentiate at point t. + + Point t to interpolate at. + Interpolated first derivative at point t. + + + + Differentiate twice at point t. + + Point t to interpolate at. + Interpolated second derivative at point t. + + + + Indefinite integral at point t. NOT SUPPORTED. + + Point t to integrate at. + + + + Definite integral between points a and b. NOT SUPPORTED. + + Left bound of the integration interval [a,b]. + Right bound of the integration interval [a,b]. + + + + Quadratic Spline Interpolation. + + Supports both differentiation and integration. + + + sample points (N+1), sorted ascending + Zero order spline coefficients (N) + First order spline coefficients (N) + second order spline coefficients (N) + + + + Gets a value indicating whether the algorithm supports differentiation (interpolated derivative). + + + + + Gets a value indicating whether the algorithm supports integration (interpolated quadrature). + + + + + Interpolate at point t. + + Point t to interpolate at. + Interpolated value x(t). + + + + Differentiate at point t. + + Point t to interpolate at. + Interpolated first derivative at point t. + + + + Differentiate twice at point t. + + Point t to interpolate at. + Interpolated second derivative at point t. + + + + Indefinite integral at point t. + + Point t to integrate at. + + + + Definite integral between points a and b. + + Left bound of the integration interval [a,b]. + Right bound of the integration interval [a,b]. + + + + Find the index of the greatest sample point smaller than t, + or the left index of the closest segment for extrapolation. + + + + + Left and right boundary conditions. + + + + + Natural Boundary (Zero second derivative). + + + + + Parabolically Terminated boundary. + + + + + Fixed first derivative at the boundary. + + + + + Fixed second derivative at the boundary. + + + + + A step function where the start of each segment is included, and the last segment is open-ended. + Segment i is [x_i, x_i+1) for i < N, or [x_i, infinity] for i = N. + The domain of the function is all real numbers, such that y = 0 where x <. + + Supports both differentiation and integration. + + + Sample points (N), sorted ascending + Samples values (N) of each segment starting at the corresponding sample point. + + + + Create a linear spline interpolation from a set of (x,y) value pairs, sorted ascendingly by x. + + + + + Create a linear spline interpolation from an unsorted set of (x,y) value pairs. + WARNING: Works in-place and can thus causes the data array to be reordered. + + + + + Create a linear spline interpolation from an unsorted set of (x,y) value pairs. + + + + + Interpolate at point t. + + Point t to interpolate at. + Interpolated value x(t). + + + + Differentiate at point t. + + Point t to interpolate at. + Interpolated first derivative at point t. + + + + Differentiate twice at point t. + + Point t to interpolate at. + Interpolated second derivative at point t. + + + + Indefinite integral at point t. + + Point t to integrate at. + + + + Definite integral between points a and b. + + Left bound of the integration interval [a,b]. + Right bound of the integration interval [a,b]. + + + + Find the index of the greatest sample point smaller than t. + + + + + Wraps an interpolation with a transformation of the interpolated values. + + Neither differentiation nor integration is supported. + + + + Create a linear spline interpolation from a set of (x,y) value pairs, sorted ascendingly by x. + + + + + Create a linear spline interpolation from an unsorted set of (x,y) value pairs. + WARNING: Works in-place and can thus causes the data array to be reordered and modified. + + + + + Create a linear spline interpolation from an unsorted set of (x,y) value pairs. + + + + + Gets a value indicating whether the algorithm supports differentiation (interpolated derivative). + + + + + Gets a value indicating whether the algorithm supports integration (interpolated quadrature). + + + + + Interpolate at point t. + + Point t to interpolate at. + Interpolated value x(t). + + + + Differentiate at point t. NOT SUPPORTED. + + Point t to interpolate at. + Interpolated first derivative at point t. + + + + Differentiate twice at point t. NOT SUPPORTED. + + Point t to interpolate at. + Interpolated second derivative at point t. + + + + Indefinite integral at point t. NOT SUPPORTED. + + Point t to integrate at. + + + + Definite integral between points a and b. NOT SUPPORTED. + + Left bound of the integration interval [a,b]. + Right bound of the integration interval [a,b]. + + + + A Matrix class with dense storage. The underlying storage is a one dimensional array in column-major order (column by column). + + + + + Number of rows. + + Using this instead of the RowCount property to speed up calculating + a matrix index in the data array. + + + + Number of columns. + + Using this instead of the ColumnCount property to speed up calculating + a matrix index in the data array. + + + + Gets the matrix's data. + + The matrix's data. + + + + Create a new dense matrix straight from an initialized matrix storage instance. + The storage is used directly without copying. + Intended for advanced scenarios where you're working directly with + storage for performance or interop reasons. + + + + + Create a new square dense matrix with the given number of rows and columns. + All cells of the matrix will be initialized to zero. + + If the order is less than one. + + + + Create a new dense matrix with the given number of rows and columns. + All cells of the matrix will be initialized to zero. + + If the row or column count is less than one. + + + + Create a new dense matrix with the given number of rows and columns directly binding to a raw array. + The array is assumed to be in column-major order (column by column) and is used directly without copying. + Very efficient, but changes to the array and the matrix will affect each other. + + + + + + Create a new dense matrix as a copy of the given other matrix. + This new matrix will be independent from the other matrix. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given two-dimensional array. + This new matrix will be independent from the provided array. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given enumerable. + The enumerable is assumed to be in column-major order (column by column). + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given enumerable of enumerable columns. + Each enumerable in the master enumerable specifies a column. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given enumerable of enumerable columns. + Each enumerable in the master enumerable specifies a column. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given column arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given column arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given column vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given column vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given enumerable of enumerable rows. + Each enumerable in the master enumerable specifies a row. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given enumerable of enumerable rows. + Each enumerable in the master enumerable specifies a row. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given row arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given row arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given row vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given row vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix with the diagonal as a copy of the given vector. + This new matrix will be independent from the vector. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix with the diagonal as a copy of the given vector. + This new matrix will be independent from the vector. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix with the diagonal as a copy of the given array. + This new matrix will be independent from the array. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix with the diagonal as a copy of the given array. + This new matrix will be independent from the array. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix and initialize each value to the same provided value. + + + + + Create a new dense matrix and initialize each value using the provided init function. + + + + + Create a new diagonal dense matrix and initialize each diagonal value to the same provided value. + + + + + Create a new diagonal dense matrix and initialize each diagonal value using the provided init function. + + + + + Create a new square sparse identity matrix where each diagonal value is set to One. + + + + + Create a new dense matrix with values sampled from the provided random distribution. + + + + + Gets the matrix's data. + + The matrix's data. + + + Calculates the induced L1 norm of this matrix. + The maximum absolute column sum of the matrix. + + + Calculates the induced infinity norm of this matrix. + The maximum absolute row sum of the matrix. + + + Calculates the entry-wise Frobenius norm of this matrix. + The square root of the sum of the squared values. + + + + Negate each element of this matrix and place the results into the result matrix. + + The result of the negation. + + + + Add a scalar to each element of the matrix and stores the result in the result vector. + + The scalar to add. + The matrix to store the result of the addition. + + + + Adds another matrix to this matrix. + + The matrix to add to this matrix. + The matrix to store the result of add + If the other matrix is . + If the two matrices don't have the same dimensions. + + + + Subtracts a scalar from each element of the matrix and stores the result in the result vector. + + The scalar to subtract. + The matrix to store the result of the subtraction. + + + + Subtracts another matrix from this matrix. + + The matrix to subtract. + The matrix to store the result of the subtraction. + + + + Multiplies each element of the matrix by a scalar and places results into the result matrix. + + The scalar to multiply the matrix with. + The matrix to store the result of the multiplication. + + + + Multiplies this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + + + + Multiplies this matrix with another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies this matrix with transpose of another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies the transpose of this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + + + + Multiplies the transpose of this matrix with another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Divides each element of the matrix by a scalar and places results into the result matrix. + + The scalar to divide the matrix with. + The matrix to store the result of the division. + + + + Pointwise multiplies this matrix with another matrix and stores the result into the result matrix. + + The matrix to pointwise multiply with this one. + The matrix to store the result of the pointwise multiplication. + + + + Pointwise divide this matrix by another matrix and stores the result into the result matrix. + + The matrix to pointwise divide this one by. + The matrix to store the result of the pointwise division. + + + + Pointwise raise this matrix to an exponent and store the result into the result matrix. + + The exponent to raise this matrix values to. + The vector to store the result of the pointwise power. + + + + Computes the canonical modulus, where the result has the sign of the divisor, + for the given divisor each element of the matrix. + + The scalar denominator to use. + Matrix to store the results in. + + + + Computes the canonical modulus, where the result has the sign of the divisor, + for the given dividend for each element of the matrix. + + The scalar numerator to use. + A vector to store the results in. + + + + Computes the remainder (% operator), where the result has the sign of the dividend, + for the given divisor each element of the matrix. + + The scalar denominator to use. + Matrix to store the results in. + + + + Computes the remainder (% operator), where the result has the sign of the dividend, + for the given dividend for each element of the matrix. + + The scalar numerator to use. + A vector to store the results in. + + + + Computes the trace of this matrix. + + The trace of this matrix + If the matrix is not square + + + + Adds two matrices together and returns the results. + + This operator will allocate new memory for the result. It will + choose the representation of either or depending on which + is denser. + The left matrix to add. + The right matrix to add. + The result of the addition. + If and don't have the same dimensions. + If or is . + + + + Returns a Matrix containing the same values of . + + The matrix to get the values from. + A matrix containing a the same values as . + If is . + + + + Subtracts two matrices together and returns the results. + + This operator will allocate new memory for the result. It will + choose the representation of either or depending on which + is denser. + The left matrix to subtract. + The right matrix to subtract. + The result of the addition. + If and don't have the same dimensions. + If or is . + + + + Negates each element of the matrix. + + The matrix to negate. + A matrix containing the negated values. + If is . + + + + Multiplies a Matrix by a constant and returns the result. + + The matrix to multiply. + The constant to multiply the matrix by. + The result of the multiplication. + If is . + + + + Multiplies a Matrix by a constant and returns the result. + + The matrix to multiply. + The constant to multiply the matrix by. + The result of the multiplication. + If is . + + + + Multiplies two matrices. + + This operator will allocate new memory for the result. It will + choose the representation of either or depending on which + is denser. + The left matrix to multiply. + The right matrix to multiply. + The result of multiplication. + If or is . + If the dimensions of or don't conform. + + + + Multiplies a Matrix and a Vector. + + The matrix to multiply. + The vector to multiply. + The result of multiplication. + If or is . + + + + Multiplies a Vector and a Matrix. + + The vector to multiply. + The matrix to multiply. + The result of multiplication. + If or is . + + + + Multiplies a Matrix by a constant and returns the result. + + The matrix to multiply. + The constant to multiply the matrix by. + The result of the multiplication. + If is . + + + + Evaluates whether this matrix is symmetric. + + + + + A vector using dense storage. + + + + + Number of elements + + + + + Gets the vector's data. + + + + + Create a new dense vector straight from an initialized vector storage instance. + The storage is used directly without copying. + Intended for advanced scenarios where you're working directly with + storage for performance or interop reasons. + + + + + Create a new dense vector with the given length. + All cells of the vector will be initialized to zero. + + If length is less than one. + + + + Create a new dense vector directly binding to a raw array. + The array is used directly without copying. + Very efficient, but changes to the array and the vector will affect each other. + + + + + Create a new dense vector as a copy of the given other vector. + This new vector will be independent from the other vector. + A new memory block will be allocated for storing the vector. + + + + + Create a new dense vector as a copy of the given array. + This new vector will be independent from the array. + A new memory block will be allocated for storing the vector. + + + + + Create a new dense vector as a copy of the given enumerable. + This new vector will be independent from the enumerable. + A new memory block will be allocated for storing the vector. + + + + + Create a new dense vector as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new vector will be independent from the enumerable. + A new memory block will be allocated for storing the vector. + + + + + Create a new dense vector as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new vector will be independent from the enumerable. + A new memory block will be allocated for storing the vector. + + + + + Create a new dense vector and initialize each value using the provided value. + + + + + Create a new dense vector and initialize each value using the provided init function. + + + + + Create a new dense vector with values sampled from the provided random distribution. + + + + + Gets the vector's data. + + The vector's data. + + + + Returns a reference to the internal data structure. + + The DenseVector whose internal data we are + returning. + + A reference to the internal date of the given vector. + + + + + Returns a vector bound directly to a reference of the provided array. + + The array to bind to the DenseVector object. + + A DenseVector whose values are bound to the given array. + + + + + Adds a scalar to each element of the vector and stores the result in the result vector. + + The scalar to add. + The vector to store the result of the addition. + + + + Adds another vector to this vector and stores the result into the result vector. + + The vector to add to this one. + The vector to store the result of the addition. + + + + Adds two Vectors together and returns the results. + + One of the vectors to add. + The other vector to add. + The result of the addition. + If and are not the same size. + If or is . + + + + Subtracts a scalar from each element of the vector and stores the result in the result vector. + + The scalar to subtract. + The vector to store the result of the subtraction. + + + + Subtracts another vector to this vector and stores the result into the result vector. + + The vector to subtract from this one. + The vector to store the result of the subtraction. + + + + Returns a Vector containing the negated values of . + + The vector to get the values from. + A vector containing the negated values as . + If is . + + + + Subtracts two Vectors and returns the results. + + The vector to subtract from. + The vector to subtract. + The result of the subtraction. + If and are not the same size. + If or is . + + + + Negates vector and saves result to + + Target vector + + + + Multiplies a scalar to each element of the vector and stores the result in the result vector. + + The scalar to multiply. + The vector to store the result of the multiplication. + + + + + Computes the dot product between this vector and another vector. + + The other vector. + The sum of a[i]*b[i] for all i. + + + + Multiplies a vector with a scalar. + + The vector to scale. + The scalar value. + The result of the multiplication. + If is . + + + + Multiplies a vector with a scalar. + + The scalar value. + The vector to scale. + The result of the multiplication. + If is . + + + + Computes the dot product between two Vectors. + + The left row vector. + The right column vector. + The dot product between the two vectors. + If and are not the same size. + If or is . + + + + Divides a vector with a scalar. + + The vector to divide. + The scalar value. + The result of the division. + If is . + + + + Computes the canonical modulus, where the result has the sign of the divisor, + for each element of the vector for the given divisor. + + The divisor to use. + A vector to store the results in. + + + + Computes the remainder (% operator), where the result has the sign of the dividend, + for each element of the vector for the given divisor. + + The divisor to use. + A vector to store the results in. + + + + Computes the remainder (% operator), where the result has the sign of the dividend, + of each element of the vector of the given divisor. + + The vector whose elements we want to compute the remainder of. + The divisor to use, + If is . + + + + Returns the index of the absolute minimum element. + + The index of absolute minimum element. + + + + Returns the index of the absolute maximum element. + + The index of absolute maximum element. + + + + Returns the index of the maximum element. + + The index of maximum element. + + + + Returns the index of the minimum element. + + The index of minimum element. + + + + Computes the sum of the vector's elements. + + The sum of the vector's elements. + + + + Calculates the L1 norm of the vector, also known as Manhattan norm. + + The sum of the absolute values. + + + + Calculates the L2 norm of the vector, also known as Euclidean norm. + + The square root of the sum of the squared values. + + + + Calculates the infinity norm of the vector. + + The maximum absolute value. + + + + Computes the p-Norm. + + The p value. + Scalar ret = ( ∑|this[i]|^p )^(1/p) + + + + Pointwise divide this vector with another vector and stores the result into the result vector. + + The vector to pointwise divide this one by. + The vector to store the result of the pointwise division. + + + + Pointwise divide this vector with another vector and stores the result into the result vector. + + The vector to pointwise divide this one by. + The vector to store the result of the pointwise division. + + + + + Pointwise raise this vector to an exponent vector and store the result into the result vector. + + The exponent vector to raise this vector values to. + The vector to store the result of the pointwise power. + + + + Creates a double dense vector based on a string. The string can be in the following formats (without the + quotes): 'n', 'n,n,..', '(n,n,..)', '[n,n,...]', where n is a double. + + + A double dense vector containing the values specified by the given string. + + + the string to parse. + + + An that supplies culture-specific formatting information. + + + + + Converts the string representation of a real dense vector to double-precision dense vector equivalent. + A return value indicates whether the conversion succeeded or failed. + + + A string containing a real vector to convert. + + + The parsed value. + + + If the conversion succeeds, the result will contain a complex number equivalent to value. + Otherwise the result will be null. + + + + + Converts the string representation of a real dense vector to double-precision dense vector equivalent. + A return value indicates whether the conversion succeeded or failed. + + + A string containing a real vector to convert. + + + An that supplies culture-specific formatting information about value. + + + The parsed value. + + + If the conversion succeeds, the result will contain a complex number equivalent to value. + Otherwise the result will be null. + + + + + A matrix type for diagonal matrices. + + + Diagonal matrices can be non-square matrices but the diagonal always starts + at element 0,0. A diagonal matrix will throw an exception if non diagonal + entries are set. The exception to this is when the off diagonal elements are + 0.0 or NaN; these settings will cause no change to the diagonal matrix. + + + + + Gets the matrix's data. + + The matrix's data. + + + + Create a new diagonal matrix straight from an initialized matrix storage instance. + The storage is used directly without copying. + Intended for advanced scenarios where you're working directly with + storage for performance or interop reasons. + + + + + Create a new square diagonal matrix with the given number of rows and columns. + All cells of the matrix will be initialized to zero. + + If the order is less than one. + + + + Create a new diagonal matrix with the given number of rows and columns. + All cells of the matrix will be initialized to zero. + + If the row or column count is less than one. + + + + Create a new diagonal matrix with the given number of rows and columns. + All diagonal cells of the matrix will be initialized to the provided value, all non-diagonal ones to zero. + + If the row or column count is less than one. + + + + Create a new diagonal matrix with the given number of rows and columns directly binding to a raw array. + The array is assumed to contain the diagonal elements only and is used directly without copying. + Very efficient, but changes to the array and the matrix will affect each other. + + + + + Create a new diagonal matrix as a copy of the given other matrix. + This new matrix will be independent from the other matrix. + The matrix to copy from must be diagonal as well. + A new memory block will be allocated for storing the matrix. + + + + + Create a new diagonal matrix as a copy of the given two-dimensional array. + This new matrix will be independent from the provided array. + The array to copy from must be diagonal as well. + A new memory block will be allocated for storing the matrix. + + + + + Create a new diagonal matrix and initialize each diagonal value from the provided indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the matrix. + + + + + Create a new diagonal matrix and initialize each diagonal value from the provided indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the matrix. + + + + + Create a new diagonal matrix and initialize each diagonal value from the provided enumerable. + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the matrix. + + + + + Create a new diagonal matrix and initialize each diagonal value using the provided init function. + + + + + Create a new square sparse identity matrix where each diagonal value is set to One. + + + + + Create a new diagonal matrix with diagonal values sampled from the provided random distribution. + + + + + Negate each element of this matrix and place the results into the result matrix. + + The result of the negation. + + + + Adds another matrix to this matrix. + + The matrix to add to this matrix. + The matrix to store the result of the addition. + If the two matrices don't have the same dimensions. + + + + Subtracts another matrix from this matrix. + + The matrix to subtract. + The matrix to store the result of the subtraction. + If the two matrices don't have the same dimensions. + + + + Multiplies each element of the matrix by a scalar and places results into the result matrix. + + The scalar to multiply the matrix with. + The matrix to store the result of the multiplication. + If the result matrix's dimensions are not the same as this matrix. + + + + Multiplies this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + + + + Multiplies this matrix with another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies this matrix with transpose of another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies the transpose of this matrix with another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies the transpose of this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + + + + Divides each element of the matrix by a scalar and places results into the result matrix. + + The scalar to divide the matrix with. + The matrix to store the result of the division. + + + + Divides a scalar by each element of the matrix and stores the result in the result matrix. + + The scalar to add. + The matrix to store the result of the division. + + + + Computes the determinant of this matrix. + + The determinant of this matrix. + + + + Returns the elements of the diagonal in a . + + The elements of the diagonal. + For non-square matrices, the method returns Min(Rows, Columns) elements where + i == j (i is the row index, and j is the column index). + + + + Copies the values of the given array to the diagonal. + + The array to copy the values from. The length of the vector should be + Min(Rows, Columns). + If the length of does not + equal Min(Rows, Columns). + For non-square matrices, the elements of are copied to + this[i,i]. + + + + Copies the values of the given to the diagonal. + + The vector to copy the values from. The length of the vector should be + Min(Rows, Columns). + If the length of does not + equal Min(Rows, Columns). + For non-square matrices, the elements of are copied to + this[i,i]. + + + Calculates the induced L1 norm of this matrix. + The maximum absolute column sum of the matrix. + + + Calculates the induced L2 norm of the matrix. + The largest singular value of the matrix. + + + Calculates the induced infinity norm of this matrix. + The maximum absolute row sum of the matrix. + + + Calculates the entry-wise Frobenius norm of this matrix. + The square root of the sum of the squared values. + + + Calculates the condition number of this matrix. + The condition number of the matrix. + + + Computes the inverse of this matrix. + If is not a square matrix. + If is singular. + The inverse of this matrix. + + + + Returns a new matrix containing the lower triangle of this matrix. + + The lower triangle of this matrix. + + + + Puts the lower triangle of this matrix into the result matrix. + + Where to store the lower triangle. + If the result matrix's dimensions are not the same as this matrix. + + + + Returns a new matrix containing the lower triangle of this matrix. The new matrix + does not contain the diagonal elements of this matrix. + + The lower triangle of this matrix. + + + + Puts the strictly lower triangle of this matrix into the result matrix. + + Where to store the lower triangle. + If the result matrix's dimensions are not the same as this matrix. + + + + Returns a new matrix containing the upper triangle of this matrix. + + The upper triangle of this matrix. + + + + Puts the upper triangle of this matrix into the result matrix. + + Where to store the lower triangle. + If the result matrix's dimensions are not the same as this matrix. + + + + Returns a new matrix containing the upper triangle of this matrix. The new matrix + does not contain the diagonal elements of this matrix. + + The upper triangle of this matrix. + + + + Puts the strictly upper triangle of this matrix into the result matrix. + + Where to store the lower triangle. + If the result matrix's dimensions are not the same as this matrix. + + + + Creates a matrix that contains the values from the requested sub-matrix. + + The row to start copying from. + The number of rows to copy. Must be positive. + The column to start copying from. + The number of columns to copy. Must be positive. + The requested sub-matrix. + If: is + negative, or greater than or equal to the number of rows. + is negative, or greater than or equal to the number + of columns. + (columnIndex + columnLength) >= Columns + (rowIndex + rowLength) >= Rows + If or + is not positive. + + + + Permute the columns of a matrix according to a permutation. + + The column permutation to apply to this matrix. + Always thrown + Permutation in diagonal matrix are senseless, because of matrix nature + + + + Permute the rows of a matrix according to a permutation. + + The row permutation to apply to this matrix. + Always thrown + Permutation in diagonal matrix are senseless, because of matrix nature + + + + Evaluates whether this matrix is symmetric. + + + + + Computes the canonical modulus, where the result has the sign of the divisor, + for the given divisor each element of the matrix. + + The scalar denominator to use. + Matrix to store the results in. + + + + Computes the canonical modulus, where the result has the sign of the divisor, + for the given dividend for each element of the matrix. + + The scalar numerator to use. + A vector to store the results in. + + + + Computes the remainder (% operator), where the result has the sign of the dividend, + for the given divisor each element of the matrix. + + The scalar denominator to use. + Matrix to store the results in. + + + + Computes the remainder (% operator), where the result has the sign of the dividend, + for the given dividend for each element of the matrix. + + The scalar numerator to use. + A vector to store the results in. + + + + A class which encapsulates the functionality of a Cholesky factorization. + For a symmetric, positive definite matrix A, the Cholesky factorization + is an lower triangular matrix L so that A = L*L'. + + + The computation of the Cholesky factorization is done at construction time. If the matrix is not symmetric + or positive definite, the constructor will throw an exception. + + + + + Gets the determinant of the matrix for which the Cholesky matrix was computed. + + + + + Gets the log determinant of the matrix for which the Cholesky matrix was computed. + + + + + A class which encapsulates the functionality of a Cholesky factorization for dense matrices. + For a symmetric, positive definite matrix A, the Cholesky factorization + is an lower triangular matrix L so that A = L*L'. + + + The computation of the Cholesky factorization is done at construction time. If the matrix is not symmetric + or positive definite, the constructor will throw an exception. + + + + + Initializes a new instance of the class. This object will compute the + Cholesky factorization when the constructor is called and cache it's factorization. + + The matrix to factor. + If is null. + If is not a square matrix. + If is not positive definite. + + + + Solves a system of linear equations, AX = B, with A Cholesky factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A Cholesky factorized. + + The right hand side vector, b. + The left hand side , x. + + + + Calculates the Cholesky factorization of the input matrix. + + The matrix to be factorized. + If is null. + If is not a square matrix. + If is not positive definite. + If does not have the same dimensions as the existing factor. + + + + Eigenvalues and eigenvectors of a real matrix. + + + If A is symmetric, then A = V*D*V' where the eigenvalue matrix D is + diagonal and the eigenvector matrix V is orthogonal. + I.e. A = V*D*V' and V*VT=I. + If A is not symmetric, then the eigenvalue matrix D is block diagonal + with the real eigenvalues in 1-by-1 blocks and any complex eigenvalues, + lambda + i*mu, in 2-by-2 blocks, [lambda, mu; -mu, lambda]. The + columns of V represent the eigenvectors in the sense that A*V = V*D, + i.e. A.Multiply(V) equals V.Multiply(D). The matrix V may be badly + conditioned, or even singular, so the validity of the equation + A = V*D*Inverse(V) depends upon V.Condition(). + + + + + Initializes a new instance of the class. This object will compute the + the eigenvalue decomposition when the constructor is called and cache it's decomposition. + + The matrix to factor. + If it is known whether the matrix is symmetric or not the routine can skip checking it itself. + If is null. + If EVD algorithm failed to converge with matrix . + + + + Solves a system of linear equations, AX = B, with A SVD factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A EVD factorized. + + The right hand side vector, b. + The left hand side , x. + + + + A class which encapsulates the functionality of the QR decomposition Modified Gram-Schmidt Orthogonalization. + Any real square matrix A may be decomposed as A = QR where Q is an orthogonal mxn matrix and R is an nxn upper triangular matrix. + + + The computation of the QR decomposition is done at construction time by modified Gram-Schmidt Orthogonalization. + + + + + Initializes a new instance of the class. This object creates an orthogonal matrix + using the modified Gram-Schmidt method. + + The matrix to factor. + If is null. + If row count is less then column count + If is rank deficient + + + + Factorize matrix using the modified Gram-Schmidt method. + + Initial matrix. On exit is replaced by Q. + Number of rows in Q. + Number of columns in Q. + On exit is filled by R. + + + + Solves a system of linear equations, AX = B, with A QR factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A QR factorized. + + The right hand side vector, b. + The left hand side , x. + + + + A class which encapsulates the functionality of an LU factorization. + For a matrix A, the LU factorization is a pair of lower triangular matrix L and + upper triangular matrix U so that A = L*U. + + + The computation of the LU factorization is done at construction time. + + + + + Initializes a new instance of the class. This object will compute the + LU factorization when the constructor is called and cache it's factorization. + + The matrix to factor. + If is null. + If is not a square matrix. + + + + Solves a system of linear equations, AX = B, with A LU factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A LU factorized. + + The right hand side vector, b. + The left hand side , x. + + + + Returns the inverse of this matrix. The inverse is calculated using LU decomposition. + + The inverse of this matrix. + + + + A class which encapsulates the functionality of the QR decomposition. + Any real square matrix A may be decomposed as A = QR where Q is an orthogonal matrix + (its columns are orthogonal unit vectors meaning QTQ = I) and R is an upper triangular matrix + (also called right triangular matrix). + + + The computation of the QR decomposition is done at construction time by Householder transformation. + + + + + Gets or sets Tau vector. Contains additional information on Q - used for native solver. + + + + + Initializes a new instance of the class. This object will compute the + QR factorization when the constructor is called and cache it's factorization. + + The matrix to factor. + The type of QR factorization to perform. + If is null. + If row count is less then column count + + + + Solves a system of linear equations, AX = B, with A QR factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A QR factorized. + + The right hand side vector, b. + The left hand side , x. + + + + A class which encapsulates the functionality of the singular value decomposition (SVD) for . + Suppose M is an m-by-n matrix whose entries are real numbers. + Then there exists a factorization of the form M = UΣVT where: + - U is an m-by-m unitary matrix; + - Σ is m-by-n diagonal matrix with nonnegative real numbers on the diagonal; + - VT denotes transpose of V, an n-by-n unitary matrix; + Such a factorization is called a singular-value decomposition of M. A common convention is to order the diagonal + entries Σ(i,i) in descending order. In this case, the diagonal matrix Σ is uniquely determined + by M (though the matrices U and V are not). The diagonal entries of Σ are known as the singular values of M. + + + The computation of the singular value decomposition is done at construction time. + + + + + Initializes a new instance of the class. This object will compute the + the singular value decomposition when the constructor is called and cache it's decomposition. + + The matrix to factor. + Compute the singular U and VT vectors or not. + If is null. + If SVD algorithm failed to converge with matrix . + + + + Solves a system of linear equations, AX = B, with A SVD factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A SVD factorized. + + The right hand side vector, b. + The left hand side , x. + + + + Eigenvalues and eigenvectors of a real matrix. + + + If A is symmetric, then A = V*D*V' where the eigenvalue matrix D is + diagonal and the eigenvector matrix V is orthogonal. + I.e. A = V*D*V' and V*VT=I. + If A is not symmetric, then the eigenvalue matrix D is block diagonal + with the real eigenvalues in 1-by-1 blocks and any complex eigenvalues, + lambda + i*mu, in 2-by-2 blocks, [lambda, mu; -mu, lambda]. The + columns of V represent the eigenvectors in the sense that A*V = V*D, + i.e. A.Multiply(V) equals V.Multiply(D). The matrix V may be badly + conditioned, or even singular, so the validity of the equation + A = V*D*Inverse(V) depends upon V.Condition(). + Matrix V is encoded in the property EigenVectors in the way that: + - column corresponding to real eigenvalue represents real eigenvector, + - columns corresponding to the pair of complex conjugate eigenvalues + lambda[i] and lambda[i+1] encode real and imaginary parts of eigenvectors. + + + + + Gets the absolute value of determinant of the square matrix for which the EVD was computed. + + + + + Gets the effective numerical matrix rank. + + The number of non-negligible singular values. + + + + Gets a value indicating whether the matrix is full rank or not. + + true if the matrix is full rank; otherwise false. + + + + A class which encapsulates the functionality of the QR decomposition Modified Gram-Schmidt Orthogonalization. + Any real square matrix A may be decomposed as A = QR where Q is an orthogonal mxn matrix and R is an nxn upper triangular matrix. + + + The computation of the QR decomposition is done at construction time by modified Gram-Schmidt Orthogonalization. + + + + + Gets the absolute determinant value of the matrix for which the QR matrix was computed. + + + + + Gets a value indicating whether the matrix is full rank or not. + + true if the matrix is full rank; otherwise false. + + + + A class which encapsulates the functionality of an LU factorization. + For a matrix A, the LU factorization is a pair of lower triangular matrix L and + upper triangular matrix U so that A = L*U. + In the Math.NET implementation we also store a set of pivot elements for increased + numerical stability. The pivot elements encode a permutation matrix P such that P*A = L*U. + + + The computation of the LU factorization is done at construction time. + + + + + Gets the determinant of the matrix for which the LU factorization was computed. + + + + + A class which encapsulates the functionality of the QR decomposition. + Any real square matrix A (m x n) may be decomposed as A = QR where Q is an orthogonal matrix + (its columns are orthogonal unit vectors meaning QTQ = I) and R is an upper triangular matrix + (also called right triangular matrix). + + + The computation of the QR decomposition is done at construction time by Householder transformation. + If a factorization is performed, the resulting Q matrix is an m x m matrix + and the R matrix is an m x n matrix. If a factorization is performed, the + resulting Q matrix is an m x n matrix and the R matrix is an n x n matrix. + + + + + Gets the absolute determinant value of the matrix for which the QR matrix was computed. + + + + + Gets a value indicating whether the matrix is full rank or not. + + true if the matrix is full rank; otherwise false. + + + + A class which encapsulates the functionality of the singular value decomposition (SVD). + Suppose M is an m-by-n matrix whose entries are real numbers. + Then there exists a factorization of the form M = UΣVT where: + - U is an m-by-m unitary matrix; + - Σ is m-by-n diagonal matrix with nonnegative real numbers on the diagonal; + - VT denotes transpose of V, an n-by-n unitary matrix; + Such a factorization is called a singular-value decomposition of M. A common convention is to order the diagonal + entries Σ(i,i) in descending order. In this case, the diagonal matrix Σ is uniquely determined + by M (though the matrices U and V are not). The diagonal entries of Σ are known as the singular values of M. + + + The computation of the singular value decomposition is done at construction time. + + + + + Gets the effective numerical matrix rank. + + The number of non-negligible singular values. + + + + Gets the two norm of the . + + The 2-norm of the . + + + + Gets the condition number max(S) / min(S) + + The condition number. + + + + Gets the determinant of the square matrix for which the SVD was computed. + + + + + A class which encapsulates the functionality of a Cholesky factorization for user matrices. + For a symmetric, positive definite matrix A, the Cholesky factorization + is an lower triangular matrix L so that A = L*L'. + + + The computation of the Cholesky factorization is done at construction time. If the matrix is not symmetric + or positive definite, the constructor will throw an exception. + + + + + Computes the Cholesky factorization in-place. + + On entry, the matrix to factor. On exit, the Cholesky factor matrix + If is null. + If is not a square matrix. + If is not positive definite. + + + + Initializes a new instance of the class. This object will compute the + Cholesky factorization when the constructor is called and cache it's factorization. + + The matrix to factor. + If is null. + If is not a square matrix. + If is not positive definite. + + + + Calculates the Cholesky factorization of the input matrix. + + The matrix to be factorized. + If is null. + If is not a square matrix. + If is not positive definite. + If does not have the same dimensions as the existing factor. + + + + Calculate Cholesky step + + Factor matrix + Number of rows + Column start + Total columns + Multipliers calculated previously + Number of available processors + + + + Solves a system of linear equations, AX = B, with A Cholesky factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A Cholesky factorized. + + The right hand side vector, b. + The left hand side , x. + + + + Eigenvalues and eigenvectors of a real matrix. + + + If A is symmetric, then A = V*D*V' where the eigenvalue matrix D is + diagonal and the eigenvector matrix V is orthogonal. + I.e. A = V*D*V' and V*VT=I. + If A is not symmetric, then the eigenvalue matrix D is block diagonal + with the real eigenvalues in 1-by-1 blocks and any complex eigenvalues, + lambda + i*mu, in 2-by-2 blocks, [lambda, mu; -mu, lambda]. The + columns of V represent the eigenvectors in the sense that A*V = V*D, + i.e. A.Multiply(V) equals V.Multiply(D). The matrix V may be badly + conditioned, or even singular, so the validity of the equation + A = V*D*Inverse(V) depends upon V.Condition(). + + + + + Initializes a new instance of the class. This object will compute the + the eigenvalue decomposition when the constructor is called and cache it's decomposition. + + The matrix to factor. + If it is known whether the matrix is symmetric or not the routine can skip checking it itself. + If is null. + If EVD algorithm failed to converge with matrix . + + + + Symmetric Householder reduction to tridiagonal form. + + The eigen vectors to work on. + Arrays for internal storage of real parts of eigenvalues + Arrays for internal storage of imaginary parts of eigenvalues + Order of initial matrix + This is derived from the Algol procedures tred2 by + Bowdler, Martin, Reinsch, and Wilkinson, Handbook for + Auto. Comp., Vol.ii-Linear Algebra, and the corresponding + Fortran subroutine in EISPACK. + + + + Symmetric tridiagonal QL algorithm. + + The eigen vectors to work on. + Arrays for internal storage of real parts of eigenvalues + Arrays for internal storage of imaginary parts of eigenvalues + Order of initial matrix + This is derived from the Algol procedures tql2, by + Bowdler, Martin, Reinsch, and Wilkinson, Handbook for + Auto. Comp., Vol.ii-Linear Algebra, and the corresponding + Fortran subroutine in EISPACK. + + + + + Nonsymmetric reduction to Hessenberg form. + + The eigen vectors to work on. + Array for internal storage of nonsymmetric Hessenberg form. + Order of initial matrix + This is derived from the Algol procedures orthes and ortran, + by Martin and Wilkinson, Handbook for Auto. Comp., + Vol.ii-Linear Algebra, and the corresponding + Fortran subroutines in EISPACK. + + + + Nonsymmetric reduction from Hessenberg to real Schur form. + + The eigen vectors to work on. + Array for internal storage of nonsymmetric Hessenberg form. + Arrays for internal storage of real parts of eigenvalues + Arrays for internal storage of imaginary parts of eigenvalues + Order of initial matrix + This is derived from the Algol procedure hqr2, + by Martin and Wilkinson, Handbook for Auto. Comp., + Vol.ii-Linear Algebra, and the corresponding + Fortran subroutine in EISPACK. + + + + Complex scalar division X/Y. + + Real part of X + Imaginary part of X + Real part of Y + Imaginary part of Y + Division result as a number. + + + + Solves a system of linear equations, AX = B, with A SVD factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A EVD factorized. + + The right hand side vector, b. + The left hand side , x. + + + + A class which encapsulates the functionality of the QR decomposition Modified Gram-Schmidt Orthogonalization. + Any real square matrix A may be decomposed as A = QR where Q is an orthogonal mxn matrix and R is an nxn upper triangular matrix. + + + The computation of the QR decomposition is done at construction time by modified Gram-Schmidt Orthogonalization. + + + + + Initializes a new instance of the class. This object creates an orthogonal matrix + using the modified Gram-Schmidt method. + + The matrix to factor. + If is null. + If row count is less then column count + If is rank deficient + + + + Solves a system of linear equations, AX = B, with A QR factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A QR factorized. + + The right hand side vector, b. + The left hand side , x. + + + + A class which encapsulates the functionality of an LU factorization. + For a matrix A, the LU factorization is a pair of lower triangular matrix L and + upper triangular matrix U so that A = L*U. + + + The computation of the LU factorization is done at construction time. + + + + + Initializes a new instance of the class. This object will compute the + LU factorization when the constructor is called and cache it's factorization. + + The matrix to factor. + If is null. + If is not a square matrix. + + + + Solves a system of linear equations, AX = B, with A LU factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A LU factorized. + + The right hand side vector, b. + The left hand side , x. + + + + Returns the inverse of this matrix. The inverse is calculated using LU decomposition. + + The inverse of this matrix. + + + + A class which encapsulates the functionality of the QR decomposition. + Any real square matrix A may be decomposed as A = QR where Q is an orthogonal matrix + (its columns are orthogonal unit vectors meaning QTQ = I) and R is an upper triangular matrix + (also called right triangular matrix). + + + The computation of the QR decomposition is done at construction time by Householder transformation. + + + + + Initializes a new instance of the class. This object will compute the + QR factorization when the constructor is called and cache it's factorization. + + The matrix to factor. + The QR factorization method to use. + If is null. + + + + Generate column from initial matrix to work array + + Initial matrix + The first row + Column index + Generated vector + + + + Perform calculation of Q or R + + Work array + Q or R matrices + The first row + The last row + The first column + The last column + Number of available CPUs + + + + Solves a system of linear equations, AX = B, with A QR factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A QR factorized. + + The right hand side vector, b. + The left hand side , x. + + + + A class which encapsulates the functionality of the singular value decomposition (SVD) for . + Suppose M is an m-by-n matrix whose entries are real numbers. + Then there exists a factorization of the form M = UΣVT where: + - U is an m-by-m unitary matrix; + - Σ is m-by-n diagonal matrix with nonnegative real numbers on the diagonal; + - VT denotes transpose of V, an n-by-n unitary matrix; + Such a factorization is called a singular-value decomposition of M. A common convention is to order the diagonal + entries Σ(i,i) in descending order. In this case, the diagonal matrix Σ is uniquely determined + by M (though the matrices U and V are not). The diagonal entries of Σ are known as the singular values of M. + + + The computation of the singular value decomposition is done at construction time. + + + + + Initializes a new instance of the class. This object will compute the + the singular value decomposition when the constructor is called and cache it's decomposition. + + The matrix to factor. + Compute the singular U and VT vectors or not. + If is null. + + + + + Calculates absolute value of multiplied on signum function of + + Double value z1 + Double value z2 + Result multiplication of signum function and absolute value + + + + Swap column and + + Source matrix + The number of rows in + Column A index to swap + Column B index to swap + + + + Scale column by starting from row + + Source matrix + The number of rows in + Column to scale + Row to scale from + Scale value + + + + Scale vector by starting from index + + Source vector + Row to scale from + Scale value + + + + Given the Cartesian coordinates (da, db) of a point p, these function return the parameters da, db, c, and s + associated with the Givens rotation that zeros the y-coordinate of the point. + + Provides the x-coordinate of the point p. On exit contains the parameter r associated with the Givens rotation + Provides the y-coordinate of the point p. On exit contains the parameter z associated with the Givens rotation + Contains the parameter c associated with the Givens rotation + Contains the parameter s associated with the Givens rotation + This is equivalent to the DROTG LAPACK routine. + + + + Calculate Norm 2 of the column in matrix starting from row + + Source matrix + The number of rows in + Column index + Start row index + Norm2 (Euclidean norm) of the column + + + + Calculate Norm 2 of the vector starting from index + + Source vector + Start index + Norm2 (Euclidean norm) of the vector + + + + Calculate dot product of and + + Source matrix + The number of rows in + Index of column A + Index of column B + Starting row index + Dot product value + + + + Performs rotation of points in the plane. Given two vectors x and y , + each vector element of these vectors is replaced as follows: x(i) = c*x(i) + s*y(i); y(i) = c*y(i) - s*x(i) + + Source matrix + The number of rows in + Index of column A + Index of column B + Scalar "c" value + Scalar "s" value + + + + Solves a system of linear equations, AX = B, with A SVD factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A SVD factorized. + + The right hand side vector, b. + The left hand side , x. + + + + double version of the class. + + + + + Initializes a new instance of the Matrix class. + + + + + Set all values whose absolute value is smaller than the threshold to zero. + + + + + Returns the conjugate transpose of this matrix. + + The conjugate transpose of this matrix. + + + + Puts the conjugate transpose of this matrix into the result matrix. + + + + + Complex conjugates each element of this matrix and place the results into the result matrix. + + The result of the conjugation. + + + + Negate each element of this matrix and place the results into the result matrix. + + The result of the negation. + + + + Add a scalar to each element of the matrix and stores the result in the result vector. + + The scalar to add. + The matrix to store the result of the addition. + + + + Adds another matrix to this matrix. + + The matrix to add to this matrix. + The matrix to store the result of the addition. + If the other matrix is . + If the two matrices don't have the same dimensions. + + + + Subtracts a scalar from each element of the vector and stores the result in the result vector. + + The scalar to subtract. + The matrix to store the result of the subtraction. + + + + Subtracts another matrix from this matrix. + + The matrix to subtract to this matrix. + The matrix to store the result of subtraction. + If the other matrix is . + If the two matrices don't have the same dimensions. + + + + Multiplies each element of the matrix by a scalar and places results into the result matrix. + + The scalar to multiply the matrix with. + The matrix to store the result of the multiplication. + + + + Multiplies this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + + + + Divides each element of the matrix by a scalar and places results into the result matrix. + + The scalar to divide the matrix with. + The matrix to store the result of the division. + + + + Divides a scalar by each element of the matrix and stores the result in the result matrix. + + The scalar to divide by each element of the matrix. + The matrix to store the result of the division. + + + + Multiplies this matrix with another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies this matrix with transpose of another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies this matrix with the conjugate transpose of another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies the transpose of this matrix with another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies the transpose of this matrix with another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies the transpose of this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + + + + Multiplies the conjugate transpose of this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + + + + Computes the canonical modulus, where the result has the sign of the divisor, + for the given divisor each element of the matrix. + + The scalar denominator to use. + Matrix to store the results in. + + + + Computes the canonical modulus, where the result has the sign of the divisor, + for the given dividend for each element of the matrix. + + The scalar numerator to use. + A vector to store the results in. + + + + Computes the remainder (% operator), where the result has the sign of the dividend, + for the given divisor each element of the matrix. + + The scalar denominator to use. + Matrix to store the results in. + + + + Computes the remainder (% operator), where the result has the sign of the dividend, + for the given dividend for each element of the matrix. + + The scalar numerator to use. + A vector to store the results in. + + + + Pointwise multiplies this matrix with another matrix and stores the result into the result matrix. + + The matrix to pointwise multiply with this one. + The matrix to store the result of the pointwise multiplication. + + + + Pointwise divide this matrix by another matrix and stores the result into the result matrix. + + The matrix to pointwise divide this one by. + The matrix to store the result of the pointwise division. + + + + Pointwise raise this matrix to an exponent and store the result into the result matrix. + + The exponent to raise this matrix values to. + The matrix to store the result of the pointwise power. + + + + Pointwise raise this matrix to an exponent and store the result into the result matrix. + + The exponent to raise this matrix values to. + The vector to store the result of the pointwise power. + + + + Pointwise canonical modulus, where the result has the sign of the divisor, + of this matrix with another matrix and stores the result into the result matrix. + + The pointwise denominator matrix to use + The result of the modulus. + + + + Pointwise remainder (% operator), where the result has the sign of the dividend, + of this matrix with another matrix and stores the result into the result matrix. + + The pointwise denominator matrix to use + The result of the modulus. + + + + Pointwise applies the exponential function to each value and stores the result into the result matrix. + + The matrix to store the result. + + + + Pointwise applies the natural logarithm function to each value and stores the result into the result matrix. + + The matrix to store the result. + + + + Computes the Moore-Penrose Pseudo-Inverse of this matrix. + + + + + Computes the trace of this matrix. + + The trace of this matrix + If the matrix is not square + + + Calculates the induced L1 norm of this matrix. + The maximum absolute column sum of the matrix. + + + Calculates the induced infinity norm of this matrix. + The maximum absolute row sum of the matrix. + + + Calculates the entry-wise Frobenius norm of this matrix. + The square root of the sum of the squared values. + + + + Calculates the p-norms of all row vectors. + Typical values for p are 1.0 (L1, Manhattan norm), 2.0 (L2, Euclidean norm) and positive infinity (infinity norm) + + + + + Calculates the p-norms of all column vectors. + Typical values for p are 1.0 (L1, Manhattan norm), 2.0 (L2, Euclidean norm) and positive infinity (infinity norm) + + + + + Normalizes all row vectors to a unit p-norm. + Typical values for p are 1.0 (L1, Manhattan norm), 2.0 (L2, Euclidean norm) and positive infinity (infinity norm) + + + + + Normalizes all column vectors to a unit p-norm. + Typical values for p are 1.0 (L1, Manhattan norm), 2.0 (L2, Euclidean norm) and positive infinity (infinity norm) + + + + + Calculates the value sum of each row vector. + + + + + Calculates the absolute value sum of each row vector. + + + + + Calculates the value sum of each column vector. + + + + + Calculates the absolute value sum of each column vector. + + + + + Evaluates whether this matrix is Hermitian (conjugate symmetric). + + + + + A Bi-Conjugate Gradient stabilized iterative matrix solver. + + + + The Bi-Conjugate Gradient Stabilized (BiCGStab) solver is an 'improvement' + of the standard Conjugate Gradient (CG) solver. Unlike the CG solver the + BiCGStab can be used on non-symmetric matrices.
    + Note that much of the success of the solver depends on the selection of the + proper preconditioner. +     + + The Bi-CGSTAB algorithm was taken from:
    + Templates for the solution of linear systems: Building blocks + for iterative methods +
    + Richard Barrett, Michael Berry, Tony F. Chan, James Demmel, + June M. Donato, Jack Dongarra, Victor Eijkhout, Roldan Pozo, + Charles Romine and Henk van der Vorst +
    + Url: http://www.netlib.org/templates/Templates.html +
    + Algorithm is described in Chapter 2, section 2.3.8, page 27 +     + + The example code below provides an indication of the possible use of the + solver. + +     +     + + + Calculates the true residual of the matrix equation Ax = b according to: residual = b - Ax + + Instance of the A. + Residual values in . + Instance of the x. + Instance of the b. + + + + Solves the matrix equation Ax = b, where A is the coefficient matrix, b is the + solution vector and x is the unknown vector. + + The coefficient , A. + The solution , b. + The result , x. + The iterator to use to control when to stop iterating. + The preconditioner to use for approximations. + + + + A composite matrix solver. The actual solver is made by a sequence of + matrix solvers. + + + + Solver based on:
    + Faster PDE-based simulations using robust composite linear solvers
    + S. Bhowmicka, P. Raghavan a,*, L. McInnes b, B. Norris
    + Future Generation Computer Systems, Vol 20, 2004, pp 373�387
    +     + + Note that if an iterator is passed to this solver it will be used for all the sub-solvers. + +     +     + + + The collection of solvers that will be used + + + + + Solves the matrix equation Ax = b, where A is the coefficient matrix, b is the + solution vector and x is the unknown vector. + + The coefficient matrix, A. + The solution vector, b + The result vector, x + The iterator to use to control when to stop iterating. + The preconditioner to use for approximations. + + + + A diagonal preconditioner. The preconditioner uses the inverse + of the matrix diagonal as preconditioning values. + + + + + The inverse of the matrix diagonal. + + + + + Returns the decomposed matrix diagonal. + + The matrix diagonal. + + + + Initializes the preconditioner and loads the internal data structures. + + + The upon which this preconditioner is based. + If is . + If is not a square matrix. + + + + Approximates the solution to the matrix equation Ax = b. + + The right hand side vector. + The left hand side vector. Also known as the result vector. + + + + A Generalized Product Bi-Conjugate Gradient iterative matrix solver. + + + + The Generalized Product Bi-Conjugate Gradient (GPBiCG) solver is an + alternative version of the Bi-Conjugate Gradient stabilized (CG) solver. + Unlike the CG solver the GPBiCG solver can be used on + non-symmetric matrices.
    + Note that much of the success of the solver depends on the selection of the + proper preconditioner. +     + + The GPBiCG algorithm was taken from:
    + GPBiCG(m,l): A hybrid of BiCGSTAB and GPBiCG methods with + efficiency and robustness +
    + S. Fujino +
    + Applied Numerical Mathematics, Volume 41, 2002, pp 107 - 117 +
    +     + + The example code below provides an indication of the possible use of the + solver. + +     +     + + + Indicates the number of BiCGStab steps should be taken + before switching. + + + + + Indicates the number of GPBiCG steps should be taken + before switching. + + + + + Gets or sets the number of steps taken with the BiCgStab algorithm + before switching over to the GPBiCG algorithm. + + + + + Gets or sets the number of steps taken with the GPBiCG algorithm + before switching over to the BiCgStab algorithm. + + + + + Calculates the true residual of the matrix equation Ax = b according to: residual = b - Ax + + Instance of the A. + Residual values in . + Instance of the x. + Instance of the b. + + + + Decide if to do steps with BiCgStab + + Number of iteration + true if yes, otherwise false + + + + Solves the matrix equation Ax = b, where A is the coefficient matrix, b is the + solution vector and x is the unknown vector. + + The coefficient matrix, A. + The solution vector, b + The result vector, x + The iterator to use to control when to stop iterating. + The preconditioner to use for approximations. + + + + An incomplete, level 0, LU factorization preconditioner. + + + The ILU(0) algorithm was taken from:
    + Iterative methods for sparse linear systems
    + Yousef Saad
    + Algorithm is described in Chapter 10, section 10.3.2, page 275
    +     +     + + + The matrix holding the lower (L) and upper (U) matrices. The + decomposition matrices are combined to reduce storage. + + + + + Returns the upper triagonal matrix that was created during the LU decomposition. + + A new matrix containing the upper triagonal elements. + + + + Returns the lower triagonal matrix that was created during the LU decomposition. + + A new matrix containing the lower triagonal elements. + + + + Initializes the preconditioner and loads the internal data structures. + + The matrix upon which the preconditioner is based. + If is . + If is not a square matrix. + + + + Approximates the solution to the matrix equation Ax = b. + + The right hand side vector. + The left hand side vector. Also known as the result vector. + + + + This class performs an Incomplete LU factorization with drop tolerance + and partial pivoting. The drop tolerance indicates which additional entries + will be dropped from the factorized LU matrices. + + + The ILUTP-Mem algorithm was taken from:
    + ILUTP_Mem: a Space-Efficient Incomplete LU Preconditioner +
    + Tzu-Yi Chen, Department of Mathematics and Computer Science,
    + Pomona College, Claremont CA 91711, USA
    + Published in:
    + Lecture Notes in Computer Science
    + Volume 3046 / 2004
    + pp. 20 - 28
    + Algorithm is described in Section 2, page 22 +     +     + + + The default fill level. + + + + + The default drop tolerance. + + + + + The decomposed upper triangular matrix. + + + + + The decomposed lower triangular matrix. + + + + + The array containing the pivot values. + + + + + The fill level. + + + + + The drop tolerance. + + + + + The pivot tolerance. + + + + + Initializes a new instance of the class with the default settings. + + + + + Initializes a new instance of the class with the specified settings. + + + The amount of fill that is allowed in the matrix. The value is a fraction of + the number of non-zero entries in the original matrix. Values should be positive. + + + The absolute drop tolerance which indicates below what absolute value an entry + will be dropped from the matrix. A drop tolerance of 0.0 means that no values + will be dropped. Values should always be positive. + + + The pivot tolerance which indicates at what level pivoting will take place. A + value of 0.0 means that no pivoting will take place. + + + + + Gets or sets the amount of fill that is allowed in the matrix. The + value is a fraction of the number of non-zero entries in the original + matrix. The standard value is 200. + + + + Values should always be positive and can be higher than 1.0. A value lower + than 1.0 means that the eventual preconditioner matrix will have fewer + non-zero entries as the original matrix. A value higher than 1.0 means that + the eventual preconditioner can have more non-zero values than the original + matrix. + + + Note that any changes to the FillLevel after creating the preconditioner + will invalidate the created preconditioner and will require a re-initialization of + the preconditioner. + + + Thrown if a negative value is provided. + + + + Gets or sets the absolute drop tolerance which indicates below what absolute value + an entry will be dropped from the matrix. The standard value is 0.0001. + + + + The values should always be positive and can be larger than 1.0. A low value will + keep more small numbers in the preconditioner matrix. A high value will remove + more small numbers from the preconditioner matrix. + + + Note that any changes to the DropTolerance after creating the preconditioner + will invalidate the created preconditioner and will require a re-initialization of + the preconditioner. + + + Thrown if a negative value is provided. + + + + Gets or sets the pivot tolerance which indicates at what level pivoting will + take place. The standard value is 0.0 which means pivoting will never take place. + + + + The pivot tolerance is used to calculate if pivoting is necessary. Pivoting + will take place if any of the values in a row is bigger than the + diagonal value of that row divided by the pivot tolerance, i.e. pivoting + will take place if row(i,j) > row(i,i) / PivotTolerance for + any j that is not equal to i. + + + Note that any changes to the PivotTolerance after creating the preconditioner + will invalidate the created preconditioner and will require a re-initialization of + the preconditioner. + + + Thrown if a negative value is provided. + + + + Returns the upper triagonal matrix that was created during the LU decomposition. + + + This method is used for debugging purposes only and should normally not be used. + + A new matrix containing the upper triagonal elements. + + + + Returns the lower triagonal matrix that was created during the LU decomposition. + + + This method is used for debugging purposes only and should normally not be used. + + A new matrix containing the lower triagonal elements. + + + + Returns the pivot array. This array is not needed for normal use because + the preconditioner will return the solution vector values in the proper order. + + + This method is used for debugging purposes only and should normally not be used. + + The pivot array. + + + + Initializes the preconditioner and loads the internal data structures. + + + The upon which this preconditioner is based. Note that the + method takes a general matrix type. However internally the data is stored + as a sparse matrix. Therefore it is not recommended to pass a dense matrix. + + If is . + If is not a square matrix. + + + + Pivot elements in the according to internal pivot array + + Row to pivot in + + + + Was pivoting already performed + + Pivots already done + Current item to pivot + true if performed, otherwise false + + + + Swap columns in the + + Source . + First column index to swap + Second column index to swap + + + + Sort vector descending, not changing vector but placing sorted indices to + + Start sort form + Sort till upper bound + Array with sorted vector indices + Source + + + + Approximates the solution to the matrix equation Ax = b. + + The right hand side vector. + The left hand side vector. Also known as the result vector. + + + + Pivot elements in according to internal pivot array + + Source . + Result after pivoting. + + + + An element sort algorithm for the class. + + + This sort algorithm is used to sort the columns in a sparse matrix based on + the value of the element on the diagonal of the matrix. + + + + + Sorts the elements of the vector in decreasing + fashion. The vector itself is not affected. + + The starting index. + The stopping index. + An array that will contain the sorted indices once the algorithm finishes. + The that contains the values that need to be sorted. + + + + Sorts the elements of the vector in decreasing + fashion using heap sort algorithm. The vector itself is not affected. + + The starting index. + The stopping index. + An array that will contain the sorted indices once the algorithm finishes. + The that contains the values that need to be sorted. + + + + Build heap for double indices + + Root position + Length of + Indices of + Target + + + + Sift double indices + + Indices of + Target + Root position + Length of + + + + Sorts the given integers in a decreasing fashion. + + The values. + + + + Sort the given integers in a decreasing fashion using heapsort algorithm + + Array of values to sort + Length of + + + + Build heap + + Target values array + Root position + Length of + + + + Sift values + + Target value array + Root position + Length of + + + + Exchange values in array + + Target values array + First value to exchange + Second value to exchange + + + + A simple milu(0) preconditioner. + + + Original Fortran code by Yousef Saad (07 January 2004) + + + + Use modified or standard ILU(0) + + + + Gets or sets a value indicating whether to use modified or standard ILU(0). + + + + + Gets a value indicating whether the preconditioner is initialized. + + + + + Initializes the preconditioner and loads the internal data structures. + + The matrix upon which the preconditioner is based. + If is . + If is not a square or is not an + instance of SparseCompressedRowMatrixStorage. + + + + Approximates the solution to the matrix equation Ax = b. + + The right hand side vector b. + The left hand side vector x. + + + + MILU0 is a simple milu(0) preconditioner. + + Order of the matrix. + Matrix values in CSR format (input). + Column indices (input). + Row pointers (input). + Matrix values in MSR format (output). + Row pointers and column indices (output). + Pointer to diagonal elements (output). + True if the modified/MILU algorithm should be used (recommended) + Returns 0 on success or k > 0 if a zero pivot was encountered at step k. + + + + A Multiple-Lanczos Bi-Conjugate Gradient stabilized iterative matrix solver. + + + + The Multiple-Lanczos Bi-Conjugate Gradient stabilized (ML(k)-BiCGStab) solver is an 'improvement' + of the standard BiCgStab solver. + + + The algorithm was taken from:
    + ML(k)BiCGSTAB: A BiCGSTAB variant based on multiple Lanczos starting vectors +
    + Man-Chung Yeung and Tony F. Chan +
    + SIAM Journal of Scientific Computing +
    + Volume 21, Number 4, pp. 1263 - 1290 +     + + The example code below provides an indication of the possible use of the + solver. + +     +     + + + The default number of starting vectors. + + + + + The collection of starting vectors which are used as the basis for the Krylov sub-space. + + + + + The number of starting vectors used by the algorithm + + + + + Gets or sets the number of starting vectors. + + + Must be larger than 1 and smaller than the number of variables in the matrix that + for which this solver will be used. + + + + + Resets the number of starting vectors to the default value. + + + + + Gets or sets a series of orthonormal vectors which will be used as basis for the + Krylov sub-space. + + + + + Gets the number of starting vectors to create + + Maximum number + Number of variables + Number of starting vectors to create + + + + Returns an array of starting vectors. + + The maximum number of starting vectors that should be created. + The number of variables. + + An array with starting vectors. The array will never be larger than the + but it may be smaller if + the is smaller than + the . + + + + + Create random vectors array + + Number of vectors + Size of each vector + Array of random vectors + + + + Calculates the true residual of the matrix equation Ax = b according to: residual = b - Ax + + Source A. + Residual data. + x data. + b data. + + + + Solves the matrix equation Ax = b, where A is the coefficient matrix, b is the + solution vector and x is the unknown vector. + + The coefficient matrix, A. + The solution vector, b + The result vector, x + The iterator to use to control when to stop iterating. + The preconditioner to use for approximations. + + + + A Transpose Free Quasi-Minimal Residual (TFQMR) iterative matrix solver. + + + + The TFQMR algorithm was taken from:
    + Iterative methods for sparse linear systems. +
    + Yousef Saad +
    + Algorithm is described in Chapter 7, section 7.4.3, page 219 +     + + The example code below provides an indication of the possible use of the + solver. + +     +     + + + Calculates the true residual of the matrix equation Ax = b according to: residual = b - Ax + + Instance of the A. + Residual values in . + Instance of the x. + Instance of the b. + + + + Is even? + + Number to check + true if even, otherwise false + + + + Solves the matrix equation Ax = b, where A is the coefficient matrix, b is the + solution vector and x is the unknown vector. + + The coefficient matrix, A. + The solution vector, b + The result vector, x + The iterator to use to control when to stop iterating. + The preconditioner to use for approximations. + + + + A Matrix with sparse storage, intended for very large matrices where most of the cells are zero. + The underlying storage scheme is 3-array compressed-sparse-row (CSR) Format. + Wikipedia - CSR. + + + + + Gets the number of non zero elements in the matrix. + + The number of non zero elements. + + + + Create a new sparse matrix straight from an initialized matrix storage instance. + The storage is used directly without copying. + Intended for advanced scenarios where you're working directly with + storage for performance or interop reasons. + + + + + Create a new square sparse matrix with the given number of rows and columns. + All cells of the matrix will be initialized to zero. + + If the order is less than one. + + + + Create a new sparse matrix with the given number of rows and columns. + All cells of the matrix will be initialized to zero. + + If the row or column count is less than one. + + + + Create a new sparse matrix as a copy of the given other matrix. + This new matrix will be independent from the other matrix. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given two-dimensional array. + This new matrix will be independent from the provided array. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given enumerable. + The enumerable is assumed to be in row-major order (row by row). + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the vector. + + + + + + Create a new sparse matrix with the given number of rows and columns as a copy of the given array. + The array is assumed to be in column-major order (column by column). + This new matrix will be independent from the provided array. + A new memory block will be allocated for storing the matrix. + + + + + + Create a new sparse matrix as a copy of the given enumerable of enumerable columns. + Each enumerable in the master enumerable specifies a column. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given enumerable of enumerable columns. + Each enumerable in the master enumerable specifies a column. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given column arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given column arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given column vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given column vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given enumerable of enumerable rows. + Each enumerable in the master enumerable specifies a row. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given enumerable of enumerable rows. + Each enumerable in the master enumerable specifies a row. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given row arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given row arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given row vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given row vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix with the diagonal as a copy of the given vector. + This new matrix will be independent from the vector. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix with the diagonal as a copy of the given vector. + This new matrix will be independent from the vector. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix with the diagonal as a copy of the given array. + This new matrix will be independent from the array. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix with the diagonal as a copy of the given array. + This new matrix will be independent from the array. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix and initialize each value to the same provided value. + + + + + Create a new sparse matrix and initialize each value using the provided init function. + + + + + Create a new diagonal sparse matrix and initialize each diagonal value to the same provided value. + + + + + Create a new diagonal sparse matrix and initialize each diagonal value using the provided init function. + + + + + Create a new square sparse identity matrix where each diagonal value is set to One. + + + + + Returns a new matrix containing the lower triangle of this matrix. + + The lower triangle of this matrix. + + + + Puts the lower triangle of this matrix into the result matrix. + + Where to store the lower triangle. + If is . + If the result matrix's dimensions are not the same as this matrix. + + + + Puts the lower triangle of this matrix into the result matrix. + + Where to store the lower triangle. + + + + Returns a new matrix containing the upper triangle of this matrix. + + The upper triangle of this matrix. + + + + Puts the upper triangle of this matrix into the result matrix. + + Where to store the lower triangle. + If is . + If the result matrix's dimensions are not the same as this matrix. + + + + Puts the upper triangle of this matrix into the result matrix. + + Where to store the lower triangle. + + + + Returns a new matrix containing the lower triangle of this matrix. The new matrix + does not contain the diagonal elements of this matrix. + + The lower triangle of this matrix. + + + + Puts the strictly lower triangle of this matrix into the result matrix. + + Where to store the lower triangle. + If is . + If the result matrix's dimensions are not the same as this matrix. + + + + Puts the strictly lower triangle of this matrix into the result matrix. + + Where to store the lower triangle. + + + + Returns a new matrix containing the upper triangle of this matrix. The new matrix + does not contain the diagonal elements of this matrix. + + The upper triangle of this matrix. + + + + Puts the strictly upper triangle of this matrix into the result matrix. + + Where to store the lower triangle. + If is . + If the result matrix's dimensions are not the same as this matrix. + + + + Puts the strictly upper triangle of this matrix into the result matrix. + + Where to store the lower triangle. + + + + Negate each element of this matrix and place the results into the result matrix. + + The result of the negation. + + + Calculates the induced infinity norm of this matrix. + The maximum absolute row sum of the matrix. + + + Calculates the entry-wise Frobenius norm of this matrix. + The square root of the sum of the squared values. + + + + Adds another matrix to this matrix. + + The matrix to add to this matrix. + The matrix to store the result of the addition. + If the other matrix is . + If the two matrices don't have the same dimensions. + + + + Subtracts another matrix from this matrix. + + The matrix to subtract to this matrix. + The matrix to store the result of subtraction. + If the other matrix is . + If the two matrices don't have the same dimensions. + + + + Multiplies each element of the matrix by a scalar and places results into the result matrix. + + The scalar to multiply the matrix with. + The matrix to store the result of the multiplication. + + + + Multiplies this matrix with another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + + + + Multiplies this matrix with transpose of another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies the transpose of this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + + + + Pointwise multiplies this matrix with another matrix and stores the result into the result matrix. + + The matrix to pointwise multiply with this one. + The matrix to store the result of the pointwise multiplication. + + + + Pointwise divide this matrix by another matrix and stores the result into the result matrix. + + The matrix to pointwise divide this one by. + The matrix to store the result of the pointwise division. + + + + Computes the canonical modulus, where the result has the sign of the divisor, + for the given divisor each element of the matrix. + + The scalar denominator to use. + Matrix to store the results in. + + + + Computes the remainder (% operator), where the result has the sign of the dividend, + for the given divisor each element of the matrix. + + The scalar denominator to use. + Matrix to store the results in. + + + + Evaluates whether this matrix is symmetric. + + + + + Adds two matrices together and returns the results. + + This operator will allocate new memory for the result. It will + choose the representation of either or depending on which + is denser. + The left matrix to add. + The right matrix to add. + The result of the addition. + If and don't have the same dimensions. + If or is . + + + + Returns a Matrix containing the same values of . + + The matrix to get the values from. + A matrix containing a the same values as . + If is . + + + + Subtracts two matrices together and returns the results. + + This operator will allocate new memory for the result. It will + choose the representation of either or depending on which + is denser. + The left matrix to subtract. + The right matrix to subtract. + The result of the addition. + If and don't have the same dimensions. + If or is . + + + + Negates each element of the matrix. + + The matrix to negate. + A matrix containing the negated values. + If is . + + + + Multiplies a Matrix by a constant and returns the result. + + The matrix to multiply. + The constant to multiply the matrix by. + The result of the multiplication. + If is . + + + + Multiplies a Matrix by a constant and returns the result. + + The matrix to multiply. + The constant to multiply the matrix by. + The result of the multiplication. + If is . + + + + Multiplies two matrices. + + This operator will allocate new memory for the result. It will + choose the representation of either or depending on which + is denser. + The left matrix to multiply. + The right matrix to multiply. + The result of multiplication. + If or is . + If the dimensions of or don't conform. + + + + Multiplies a Matrix and a Vector. + + The matrix to multiply. + The vector to multiply. + The result of multiplication. + If or is . + + + + Multiplies a Vector and a Matrix. + + The vector to multiply. + The matrix to multiply. + The result of multiplication. + If or is . + + + + Multiplies a Matrix by a constant and returns the result. + + The matrix to multiply. + The constant to multiply the matrix by. + The result of the multiplication. + If is . + + + + A vector with sparse storage, intended for very large vectors where most of the cells are zero. + + The sparse vector is not thread safe. + + + + Gets the number of non zero elements in the vector. + + The number of non zero elements. + + + + Create a new sparse vector straight from an initialized vector storage instance. + The storage is used directly without copying. + Intended for advanced scenarios where you're working directly with + storage for performance or interop reasons. + + + + + Create a new sparse vector with the given length. + All cells of the vector will be initialized to zero. + + If length is less than one. + + + + Create a new sparse vector as a copy of the given other vector. + This new vector will be independent from the other vector. + A new memory block will be allocated for storing the vector. + + + + + Create a new sparse vector as a copy of the given enumerable. + This new vector will be independent from the enumerable. + A new memory block will be allocated for storing the vector. + + + + + Create a new sparse vector as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new vector will be independent from the enumerable. + A new memory block will be allocated for storing the vector. + + + + + Create a new sparse vector as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new vector will be independent from the enumerable. + A new memory block will be allocated for storing the vector. + + + + + Create a new sparse vector and initialize each value using the provided value. + + + + + Create a new sparse vector and initialize each value using the provided init function. + + + + + Adds a scalar to each element of the vector and stores the result in the result vector. + Warning, the new 'sparse vector' with a non-zero scalar added to it will be a 100% filled + sparse vector and very inefficient. Would be better to work with a dense vector instead. + + + The scalar to add. + + + The vector to store the result of the addition. + + + + + Adds another vector to this vector and stores the result into the result vector. + + + The vector to add to this one. + + + The vector to store the result of the addition. + + + + + Subtracts a scalar from each element of the vector and stores the result in the result vector. + + + The scalar to subtract. + + + The vector to store the result of the subtraction. + + + + + Subtracts another vector to this vector and stores the result into the result vector. + + + The vector to subtract from this one. + + + The vector to store the result of the subtraction. + + + + + Negates vector and saves result to + + Target vector + + + + Multiplies a scalar to each element of the vector and stores the result in the result vector. + + + The scalar to multiply. + + + The vector to store the result of the multiplication. + + + + + Computes the dot product between this vector and another vector. + + The other vector. + The sum of a[i]*b[i] for all i. + + + + Computes the canonical modulus, where the result has the sign of the divisor, + for each element of the vector for the given divisor. + + The scalar denominator to use. + A vector to store the results in. + + + + Computes the remainder (% operator), where the result has the sign of the dividend, + for each element of the vector for the given divisor. + + The scalar denominator to use. + A vector to store the results in. + + + + Adds two Vectors together and returns the results. + + One of the vectors to add. + The other vector to add. + The result of the addition. + If and are not the same size. + If or is . + + + + Returns a Vector containing the negated values of . + + The vector to get the values from. + A vector containing the negated values as . + If is . + + + + Subtracts two Vectors and returns the results. + + The vector to subtract from. + The vector to subtract. + The result of the subtraction. + If and are not the same size. + If or is . + + + + Multiplies a vector with a scalar. + + The vector to scale. + The scalar value. + The result of the multiplication. + If is . + + + + Multiplies a vector with a scalar. + + The scalar value. + The vector to scale. + The result of the multiplication. + If is . + + + + Computes the dot product between two Vectors. + + The left row vector. + The right column vector. + The dot product between the two vectors. + If and are not the same size. + If or is . + + + + Divides a vector with a scalar. + + The vector to divide. + The scalar value. + The result of the division. + If is . + + + + Computes the remainder (% operator), where the result has the sign of the dividend, + of each element of the vector of the given divisor. + + The vector whose elements we want to compute the modulus of. + The divisor to use, + The result of the calculation + If is . + + + + Returns the index of the absolute minimum element. + + The index of absolute minimum element. + + + + Returns the index of the absolute maximum element. + + The index of absolute maximum element. + + + + Returns the index of the maximum element. + + The index of maximum element. + + + + Returns the index of the minimum element. + + The index of minimum element. + + + + Computes the sum of the vector's elements. + + The sum of the vector's elements. + + + + Calculates the L1 norm of the vector, also known as Manhattan norm. + + The sum of the absolute values. + + + + Calculates the infinity norm of the vector. + + The maximum absolute value. + + + + Computes the p-Norm. + + The p value. + Scalar ret = ( ∑|this[i]|^p )^(1/p) + + + + Pointwise multiplies this vector with another vector and stores the result into the result vector. + + The vector to pointwise multiply with this one. + The vector to store the result of the pointwise multiplication. + + + + Creates a double sparse vector based on a string. The string can be in the following formats (without the + quotes): 'n', 'n,n,..', '(n,n,..)', '[n,n,...]', where n is a double. + + + A double sparse vector containing the values specified by the given string. + + + the string to parse. + + + An that supplies culture-specific formatting information. + + + + + Converts the string representation of a real sparse vector to double-precision sparse vector equivalent. + A return value indicates whether the conversion succeeded or failed. + + + A string containing a real vector to convert. + + + The parsed value. + + + If the conversion succeeds, the result will contain a complex number equivalent to value. + Otherwise the result will be null. + + + + + Converts the string representation of a real sparse vector to double-precision sparse vector equivalent. + A return value indicates whether the conversion succeeded or failed. + + + A string containing a real vector to convert. + + + An that supplies culture-specific formatting information about value. + + + The parsed value. + + + If the conversion succeeds, the result will contain a complex number equivalent to value. + Otherwise the result will be null. + + + + + double version of the class. + + + + + Initializes a new instance of the Vector class. + + + + + Set all values whose absolute value is smaller than the threshold to zero. + + + + + Conjugates vector and save result to + + Target vector + + + + Negates vector and saves result to + + Target vector + + + + Adds a scalar to each element of the vector and stores the result in the result vector. + + + The scalar to add. + + + The vector to store the result of the addition. + + + + + Adds another vector to this vector and stores the result into the result vector. + + + The vector to add to this one. + + + The vector to store the result of the addition. + + + + + Subtracts a scalar from each element of the vector and stores the result in the result vector. + + + The scalar to subtract. + + + The vector to store the result of the subtraction. + + + + + Subtracts another vector to this vector and stores the result into the result vector. + + + The vector to subtract from this one. + + + The vector to store the result of the subtraction. + + + + + Multiplies a scalar to each element of the vector and stores the result in the result vector. + + + The scalar to multiply. + + + The vector to store the result of the multiplication. + + + + + Divides each element of the vector by a scalar and stores the result in the result vector. + + + The scalar to divide with. + + + The vector to store the result of the division. + + + + + Divides a scalar by each element of the vector and stores the result in the result vector. + + The scalar to divide. + The vector to store the result of the division. + + + + Pointwise multiplies this vector with another vector and stores the result into the result vector. + + The vector to pointwise multiply with this one. + The vector to store the result of the pointwise multiplication. + + + + Pointwise divide this vector with another vector and stores the result into the result vector. + + The vector to pointwise divide this one by. + The vector to store the result of the pointwise division. + + + + Pointwise raise this vector to an exponent and store the result into the result vector. + + The exponent to raise this vector values to. + The vector to store the result of the pointwise power. + + + + Pointwise raise this vector to an exponent vector and store the result into the result vector. + + The exponent vector to raise this vector values to. + The vector to store the result of the pointwise power. + + + + Pointwise canonical modulus, where the result has the sign of the divisor, + of this vector with another vector and stores the result into the result vector. + + The pointwise denominator vector to use. + The result of the modulus. + + + + Pointwise remainder (% operator), where the result has the sign of the dividend, + of this vector with another vector and stores the result into the result vector. + + The pointwise denominator vector to use. + The result of the modulus. + + + + Pointwise applies the exponential function to each value and stores the result into the result vector. + + The vector to store the result. + + + + Pointwise applies the natural logarithm function to each value and stores the result into the result vector. + + The vector to store the result. + + + + Computes the dot product between this vector and another vector. + + The other vector. + The sum of a[i]*b[i] for all i. + + + + Computes the dot product between the conjugate of this vector and another vector. + + The other vector. + The sum of conj(a[i])*b[i] for all i. + + + + Computes the canonical modulus, where the result has the sign of the divisor, + for each element of the vector for the given divisor. + + The scalar denominator to use. + A vector to store the results in. + + + + Computes the canonical modulus, where the result has the sign of the divisor, + for the given dividend for each element of the vector. + + The scalar numerator to use. + A vector to store the results in. + + + + Computes the remainder (% operator), where the result has the sign of the dividend, + for each element of the vector for the given divisor. + + The scalar denominator to use. + A vector to store the results in. + + + + Computes the remainder (% operator), where the result has the sign of the dividend, + for the given dividend for each element of the vector. + + The scalar numerator to use. + A vector to store the results in. + + + + Returns the value of the absolute minimum element. + + The value of the absolute minimum element. + + + + Returns the index of the absolute minimum element. + + The index of absolute minimum element. + + + + Returns the value of the absolute maximum element. + + The value of the absolute maximum element. + + + + Returns the index of the absolute maximum element. + + The index of absolute maximum element. + + + + Computes the sum of the vector's elements. + + The sum of the vector's elements. + + + + Calculates the L1 norm of the vector, also known as Manhattan norm. + + The sum of the absolute values. + + + + Calculates the L2 norm of the vector, also known as Euclidean norm. + + The square root of the sum of the squared values. + + + + Calculates the infinity norm of the vector. + + The maximum absolute value. + + + + Computes the p-Norm. + + + The p value. + + + Scalar ret = ( ∑|At(i)|^p )^(1/p) + + + + + Returns the index of the maximum element. + + The index of maximum element. + + + + Returns the index of the minimum element. + + The index of minimum element. + + + + Normalizes this vector to a unit vector with respect to the p-norm. + + + The p value. + + + This vector normalized to a unit vector with respect to the p-norm. + + + + + A Matrix class with dense storage. The underlying storage is a one dimensional array in column-major order (column by column). + + + + + Number of rows. + + Using this instead of the RowCount property to speed up calculating + a matrix index in the data array. + + + + Number of columns. + + Using this instead of the ColumnCount property to speed up calculating + a matrix index in the data array. + + + + Gets the matrix's data. + + The matrix's data. + + + + Create a new dense matrix straight from an initialized matrix storage instance. + The storage is used directly without copying. + Intended for advanced scenarios where you're working directly with + storage for performance or interop reasons. + + + + + Create a new square dense matrix with the given number of rows and columns. + All cells of the matrix will be initialized to zero. + + If the order is less than one. + + + + Create a new dense matrix with the given number of rows and columns. + All cells of the matrix will be initialized to zero. + + If the row or column count is less than one. + + + + Create a new dense matrix with the given number of rows and columns directly binding to a raw array. + The array is assumed to be in column-major order (column by column) and is used directly without copying. + Very efficient, but changes to the array and the matrix will affect each other. + + + + + + Create a new dense matrix as a copy of the given other matrix. + This new matrix will be independent from the other matrix. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given two-dimensional array. + This new matrix will be independent from the provided array. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given enumerable. + The enumerable is assumed to be in column-major order (column by column). + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given enumerable of enumerable columns. + Each enumerable in the master enumerable specifies a column. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given enumerable of enumerable columns. + Each enumerable in the master enumerable specifies a column. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given column arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given column arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given column vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given column vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given enumerable of enumerable rows. + Each enumerable in the master enumerable specifies a row. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given enumerable of enumerable rows. + Each enumerable in the master enumerable specifies a row. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given row arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given row arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given row vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given row vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix with the diagonal as a copy of the given vector. + This new matrix will be independent from the vector. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix with the diagonal as a copy of the given vector. + This new matrix will be independent from the vector. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix with the diagonal as a copy of the given array. + This new matrix will be independent from the array. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix with the diagonal as a copy of the given array. + This new matrix will be independent from the array. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix and initialize each value to the same provided value. + + + + + Create a new dense matrix and initialize each value using the provided init function. + + + + + Create a new diagonal dense matrix and initialize each diagonal value to the same provided value. + + + + + Create a new diagonal dense matrix and initialize each diagonal value using the provided init function. + + + + + Create a new square sparse identity matrix where each diagonal value is set to One. + + + + + Create a new dense matrix with values sampled from the provided random distribution. + + + + + Gets the matrix's data. + + The matrix's data. + + + Calculates the induced L1 norm of this matrix. + The maximum absolute column sum of the matrix. + + + Calculates the induced infinity norm of this matrix. + The maximum absolute row sum of the matrix. + + + Calculates the entry-wise Frobenius norm of this matrix. + The square root of the sum of the squared values. + + + + Negate each element of this matrix and place the results into the result matrix. + + The result of the negation. + + + + Add a scalar to each element of the matrix and stores the result in the result vector. + + The scalar to add. + The matrix to store the result of the addition. + + + + Adds another matrix to this matrix. + + The matrix to add to this matrix. + The matrix to store the result of add + If the other matrix is . + If the two matrices don't have the same dimensions. + + + + Subtracts a scalar from each element of the matrix and stores the result in the result vector. + + The scalar to subtract. + The matrix to store the result of the subtraction. + + + + Subtracts another matrix from this matrix. + + The matrix to subtract. + The matrix to store the result of the subtraction. + + + + Multiplies each element of the matrix by a scalar and places results into the result matrix. + + The scalar to multiply the matrix with. + The matrix to store the result of the multiplication. + + + + Multiplies this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + + + + Multiplies this matrix with another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies this matrix with transpose of another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies the transpose of this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + + + + Multiplies the transpose of this matrix with another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Divides each element of the matrix by a scalar and places results into the result matrix. + + The scalar to divide the matrix with. + The matrix to store the result of the division. + + + + Pointwise multiplies this matrix with another matrix and stores the result into the result matrix. + + The matrix to pointwise multiply with this one. + The matrix to store the result of the pointwise multiplication. + + + + Pointwise divide this matrix by another matrix and stores the result into the result matrix. + + The matrix to pointwise divide this one by. + The matrix to store the result of the pointwise division. + + + + Pointwise raise this matrix to an exponent and store the result into the result matrix. + + The exponent to raise this matrix values to. + The vector to store the result of the pointwise power. + + + + Computes the canonical modulus, where the result has the sign of the divisor, + for the given divisor each element of the matrix. + + The scalar denominator to use. + Matrix to store the results in. + + + + Computes the canonical modulus, where the result has the sign of the divisor, + for the given dividend for each element of the matrix. + + The scalar numerator to use. + A vector to store the results in. + + + + Computes the remainder (% operator), where the result has the sign of the dividend, + for the given divisor each element of the matrix. + + The scalar denominator to use. + Matrix to store the results in. + + + + Computes the remainder (% operator), where the result has the sign of the dividend, + for the given dividend for each element of the matrix. + + The scalar numerator to use. + A vector to store the results in. + + + + Computes the trace of this matrix. + + The trace of this matrix + If the matrix is not square + + + + Adds two matrices together and returns the results. + + This operator will allocate new memory for the result. It will + choose the representation of either or depending on which + is denser. + The left matrix to add. + The right matrix to add. + The result of the addition. + If and don't have the same dimensions. + If or is . + + + + Returns a Matrix containing the same values of . + + The matrix to get the values from. + A matrix containing a the same values as . + If is . + + + + Subtracts two matrices together and returns the results. + + This operator will allocate new memory for the result. It will + choose the representation of either or depending on which + is denser. + The left matrix to subtract. + The right matrix to subtract. + The result of the addition. + If and don't have the same dimensions. + If or is . + + + + Negates each element of the matrix. + + The matrix to negate. + A matrix containing the negated values. + If is . + + + + Multiplies a Matrix by a constant and returns the result. + + The matrix to multiply. + The constant to multiply the matrix by. + The result of the multiplication. + If is . + + + + Multiplies a Matrix by a constant and returns the result. + + The matrix to multiply. + The constant to multiply the matrix by. + The result of the multiplication. + If is . + + + + Multiplies two matrices. + + This operator will allocate new memory for the result. It will + choose the representation of either or depending on which + is denser. + The left matrix to multiply. + The right matrix to multiply. + The result of multiplication. + If or is . + If the dimensions of or don't conform. + + + + Multiplies a Matrix and a Vector. + + The matrix to multiply. + The vector to multiply. + The result of multiplication. + If or is . + + + + Multiplies a Vector and a Matrix. + + The vector to multiply. + The matrix to multiply. + The result of multiplication. + If or is . + + + + Multiplies a Matrix by a constant and returns the result. + + The matrix to multiply. + The constant to multiply the matrix by. + The result of the multiplication. + If is . + + + + Evaluates whether this matrix is symmetric. + + + + + A vector using dense storage. + + + + + Number of elements + + + + + Gets the vector's data. + + + + + Create a new dense vector straight from an initialized vector storage instance. + The storage is used directly without copying. + Intended for advanced scenarios where you're working directly with + storage for performance or interop reasons. + + + + + Create a new dense vector with the given length. + All cells of the vector will be initialized to zero. + + If length is less than one. + + + + Create a new dense vector directly binding to a raw array. + The array is used directly without copying. + Very efficient, but changes to the array and the vector will affect each other. + + + + + Create a new dense vector as a copy of the given other vector. + This new vector will be independent from the other vector. + A new memory block will be allocated for storing the vector. + + + + + Create a new dense vector as a copy of the given array. + This new vector will be independent from the array. + A new memory block will be allocated for storing the vector. + + + + + Create a new dense vector as a copy of the given enumerable. + This new vector will be independent from the enumerable. + A new memory block will be allocated for storing the vector. + + + + + Create a new dense vector as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new vector will be independent from the enumerable. + A new memory block will be allocated for storing the vector. + + + + + Create a new dense vector as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new vector will be independent from the enumerable. + A new memory block will be allocated for storing the vector. + + + + + Create a new dense vector and initialize each value using the provided value. + + + + + Create a new dense vector and initialize each value using the provided init function. + + + + + Create a new dense vector with values sampled from the provided random distribution. + + + + + Gets the vector's data. + + The vector's data. + + + + Returns a reference to the internal data structure. + + The DenseVector whose internal data we are + returning. + + A reference to the internal date of the given vector. + + + + + Returns a vector bound directly to a reference of the provided array. + + The array to bind to the DenseVector object. + + A DenseVector whose values are bound to the given array. + + + + + Adds a scalar to each element of the vector and stores the result in the result vector. + + The scalar to add. + The vector to store the result of the addition. + + + + Adds another vector to this vector and stores the result into the result vector. + + The vector to add to this one. + The vector to store the result of the addition. + + + + Adds two Vectors together and returns the results. + + One of the vectors to add. + The other vector to add. + The result of the addition. + If and are not the same size. + If or is . + + + + Subtracts a scalar from each element of the vector and stores the result in the result vector. + + The scalar to subtract. + The vector to store the result of the subtraction. + + + + Subtracts another vector from this vector and stores the result into the result vector. + + The vector to subtract from this one. + The vector to store the result of the subtraction. + + + + Returns a Vector containing the negated values of . + + The vector to get the values from. + A vector containing the negated values as . + If is . + + + + Subtracts two Vectors and returns the results. + + The vector to subtract from. + The vector to subtract. + The result of the subtraction. + If and are not the same size. + If or is . + + + + Negates vector and saves result to + + Target vector + + + + Multiplies a scalar to each element of the vector and stores the result in the result vector. + + The scalar to multiply. + The vector to store the result of the multiplication. + + + + + Computes the dot product between this vector and another vector. + + The other vector. + The sum of a[i]*b[i] for all i. + + + + Multiplies a vector with a scalar. + + The vector to scale. + The scalar value. + The result of the multiplication. + If is . + + + + Multiplies a vector with a scalar. + + The scalar value. + The vector to scale. + The result of the multiplication. + If is . + + + + Computes the dot product between two Vectors. + + The left row vector. + The right column vector. + The dot product between the two vectors. + If and are not the same size. + If or is . + + + + Divides a vector with a scalar. + + The vector to divide. + The scalar value. + The result of the division. + If is . + + + + Computes the canonical modulus, where the result has the sign of the divisor, + for each element of the vector for the given divisor. + + The scalar denominator to use. + A vector to store the results in. + + + + Computes the remainder (% operator), where the result has the sign of the dividend, + for each element of the vector for the given divisor. + + The scalar denominator to use. + A vector to store the results in. + + + + Computes the remainder (% operator), where the result has the sign of the dividend, + of each element of the vector of the given divisor. + + The vector whose elements we want to compute the modulus of. + The divisor to use, + The result of the calculation + If is . + + + + Returns the index of the absolute minimum element. + + The index of absolute minimum element. + + + + Returns the index of the absolute maximum element. + + The index of absolute maximum element. + + + + Returns the index of the maximum element. + + The index of maximum element. + + + + Returns the index of the minimum element. + + The index of minimum element. + + + + Computes the sum of the vector's elements. + + The sum of the vector's elements. + + + + Calculates the L1 norm of the vector, also known as Manhattan norm. + + The sum of the absolute values. + + + + Calculates the L2 norm of the vector, also known as Euclidean norm. + + The square root of the sum of the squared values. + + + + Calculates the infinity norm of the vector. + + The maximum absolute value. + + + + Computes the p-Norm. + + The p value. + Scalar ret = ( ∑|this[i]|^p )^(1/p) + + + + Pointwise multiply this vector with another vector and stores the result into the result vector. + + The vector to pointwise multiply this one by. + The vector to store the result of the pointwise multiplication. + + + + Pointwise divide this vector with another vector and stores the result into the result vector. + + The vector to pointwise divide this one by. + The vector to store the result of the pointwise division. + + + + + Pointwise raise this vector to an exponent vector and store the result into the result vector. + + The exponent vector to raise this vector values to. + The vector to store the result of the pointwise power. + + + + Creates a float dense vector based on a string. The string can be in the following formats (without the + quotes): 'n', 'n,n,..', '(n,n,..)', '[n,n,...]', where n is a float. + + + A float dense vector containing the values specified by the given string. + + + the string to parse. + + + An that supplies culture-specific formatting information. + + + + + Converts the string representation of a real dense vector to float-precision dense vector equivalent. + A return value indicates whether the conversion succeeded or failed. + + + A string containing a real vector to convert. + + + The parsed value. + + + If the conversion succeeds, the result will contain a complex number equivalent to value. + Otherwise the result will be null. + + + + + Converts the string representation of a real dense vector to float-precision dense vector equivalent. + A return value indicates whether the conversion succeeded or failed. + + + A string containing a real vector to convert. + + + An that supplies culture-specific formatting information about value. + + + The parsed value. + + + If the conversion succeeds, the result will contain a complex number equivalent to value. + Otherwise the result will be null. + + + + + A matrix type for diagonal matrices. + + + Diagonal matrices can be non-square matrices but the diagonal always starts + at element 0,0. A diagonal matrix will throw an exception if non diagonal + entries are set. The exception to this is when the off diagonal elements are + 0.0 or NaN; these settings will cause no change to the diagonal matrix. + + + + + Gets the matrix's data. + + The matrix's data. + + + + Create a new diagonal matrix straight from an initialized matrix storage instance. + The storage is used directly without copying. + Intended for advanced scenarios where you're working directly with + storage for performance or interop reasons. + + + + + Create a new square diagonal matrix with the given number of rows and columns. + All cells of the matrix will be initialized to zero. + + If the order is less than one. + + + + Create a new diagonal matrix with the given number of rows and columns. + All cells of the matrix will be initialized to zero. + + If the row or column count is less than one. + + + + Create a new diagonal matrix with the given number of rows and columns. + All diagonal cells of the matrix will be initialized to the provided value, all non-diagonal ones to zero. + + If the row or column count is less than one. + + + + Create a new diagonal matrix with the given number of rows and columns directly binding to a raw array. + The array is assumed to contain the diagonal elements only and is used directly without copying. + Very efficient, but changes to the array and the matrix will affect each other. + + + + + Create a new diagonal matrix as a copy of the given other matrix. + This new matrix will be independent from the other matrix. + The matrix to copy from must be diagonal as well. + A new memory block will be allocated for storing the matrix. + + + + + Create a new diagonal matrix as a copy of the given two-dimensional array. + This new matrix will be independent from the provided array. + The array to copy from must be diagonal as well. + A new memory block will be allocated for storing the matrix. + + + + + Create a new diagonal matrix and initialize each diagonal value from the provided indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the matrix. + + + + + Create a new diagonal matrix and initialize each diagonal value from the provided indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the matrix. + + + + + Create a new diagonal matrix and initialize each diagonal value from the provided enumerable. + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the matrix. + + + + + Create a new diagonal matrix and initialize each diagonal value using the provided init function. + + + + + Create a new square sparse identity matrix where each diagonal value is set to One. + + + + + Create a new diagonal matrix with diagonal values sampled from the provided random distribution. + + + + + Negate each element of this matrix and place the results into the result matrix. + + The result of the negation. + + + + Adds another matrix to this matrix. + + The matrix to add to this matrix. + The matrix to store the result of the addition. + If the two matrices don't have the same dimensions. + + + + Subtracts another matrix from this matrix. + + The matrix to subtract. + The matrix to store the result of the subtraction. + If the two matrices don't have the same dimensions. + + + + Multiplies each element of the matrix by a scalar and places results into the result matrix. + + The scalar to multiply the matrix with. + The matrix to store the result of the multiplication. + If the result matrix's dimensions are not the same as this matrix. + + + + Multiplies this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + + + + Multiplies this matrix with another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies this matrix with transpose of another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies the transpose of this matrix with another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies the transpose of this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + + + + Divides each element of the matrix by a scalar and places results into the result matrix. + + The scalar to divide the matrix with. + The matrix to store the result of the division. + + + + Divides a scalar by each element of the matrix and stores the result in the result matrix. + + The scalar to add. + The matrix to store the result of the division. + + + + Computes the determinant of this matrix. + + The determinant of this matrix. + + + + Returns the elements of the diagonal in a . + + The elements of the diagonal. + For non-square matrices, the method returns Min(Rows, Columns) elements where + i == j (i is the row index, and j is the column index). + + + + Copies the values of the given array to the diagonal. + + The array to copy the values from. The length of the vector should be + Min(Rows, Columns). + If the length of does not + equal Min(Rows, Columns). + For non-square matrices, the elements of are copied to + this[i,i]. + + + + Copies the values of the given to the diagonal. + + The vector to copy the values from. The length of the vector should be + Min(Rows, Columns). + If the length of does not + equal Min(Rows, Columns). + For non-square matrices, the elements of are copied to + this[i,i]. + + + Calculates the induced L1 norm of this matrix. + The maximum absolute column sum of the matrix. + + + Calculates the induced L2 norm of the matrix. + The largest singular value of the matrix. + + + Calculates the induced infinity norm of this matrix. + The maximum absolute row sum of the matrix. + + + Calculates the entry-wise Frobenius norm of this matrix. + The square root of the sum of the squared values. + + + Calculates the condition number of this matrix. + The condition number of the matrix. + + + Computes the inverse of this matrix. + If is not a square matrix. + If is singular. + The inverse of this matrix. + + + + Returns a new matrix containing the lower triangle of this matrix. + + The lower triangle of this matrix. + + + + Puts the lower triangle of this matrix into the result matrix. + + Where to store the lower triangle. + If the result matrix's dimensions are not the same as this matrix. + + + + Returns a new matrix containing the lower triangle of this matrix. The new matrix + does not contain the diagonal elements of this matrix. + + The lower triangle of this matrix. + + + + Puts the strictly lower triangle of this matrix into the result matrix. + + Where to store the lower triangle. + If the result matrix's dimensions are not the same as this matrix. + + + + Returns a new matrix containing the upper triangle of this matrix. + + The upper triangle of this matrix. + + + + Puts the upper triangle of this matrix into the result matrix. + + Where to store the lower triangle. + If the result matrix's dimensions are not the same as this matrix. + + + + Returns a new matrix containing the upper triangle of this matrix. The new matrix + does not contain the diagonal elements of this matrix. + + The upper triangle of this matrix. + + + + Puts the strictly upper triangle of this matrix into the result matrix. + + Where to store the lower triangle. + If the result matrix's dimensions are not the same as this matrix. + + + + Creates a matrix that contains the values from the requested sub-matrix. + + The row to start copying from. + The number of rows to copy. Must be positive. + The column to start copying from. + The number of columns to copy. Must be positive. + The requested sub-matrix. + If: is + negative, or greater than or equal to the number of rows. + is negative, or greater than or equal to the number + of columns. + (columnIndex + columnLength) >= Columns + (rowIndex + rowLength) >= Rows + If or + is not positive. + + + + Permute the columns of a matrix according to a permutation. + + The column permutation to apply to this matrix. + Always thrown + Permutation in diagonal matrix are senseless, because of matrix nature + + + + Permute the rows of a matrix according to a permutation. + + The row permutation to apply to this matrix. + Always thrown + Permutation in diagonal matrix are senseless, because of matrix nature + + + + Evaluates whether this matrix is symmetric. + + + + + Computes the canonical modulus, where the result has the sign of the divisor, + for the given divisor each element of the matrix. + + The scalar denominator to use. + Matrix to store the results in. + + + + Computes the canonical modulus, where the result has the sign of the divisor, + for the given dividend for each element of the matrix. + + The scalar numerator to use. + A vector to store the results in. + + + + Computes the remainder (% operator), where the result has the sign of the dividend, + for the given divisor each element of the matrix. + + The scalar denominator to use. + Matrix to store the results in. + + + + Computes the remainder (% operator), where the result has the sign of the dividend, + for the given dividend for each element of the matrix. + + The scalar numerator to use. + A vector to store the results in. + + + + A class which encapsulates the functionality of a Cholesky factorization. + For a symmetric, positive definite matrix A, the Cholesky factorization + is an lower triangular matrix L so that A = L*L'. + + + The computation of the Cholesky factorization is done at construction time. If the matrix is not symmetric + or positive definite, the constructor will throw an exception. + + + + + Gets the determinant of the matrix for which the Cholesky matrix was computed. + + + + + Gets the log determinant of the matrix for which the Cholesky matrix was computed. + + + + + A class which encapsulates the functionality of a Cholesky factorization for dense matrices. + For a symmetric, positive definite matrix A, the Cholesky factorization + is an lower triangular matrix L so that A = L*L'. + + + The computation of the Cholesky factorization is done at construction time. If the matrix is not symmetric + or positive definite, the constructor will throw an exception. + + + + + Initializes a new instance of the class. This object will compute the + Cholesky factorization when the constructor is called and cache it's factorization. + + The matrix to factor. + If is null. + If is not a square matrix. + If is not positive definite. + + + + Solves a system of linear equations, AX = B, with A Cholesky factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A Cholesky factorized. + + The right hand side vector, b. + The left hand side , x. + + + + Calculates the Cholesky factorization of the input matrix. + + The matrix to be factorized. + If is null. + If is not a square matrix. + If is not positive definite. + If does not have the same dimensions as the existing factor. + + + + Eigenvalues and eigenvectors of a real matrix. + + + If A is symmetric, then A = V*D*V' where the eigenvalue matrix D is + diagonal and the eigenvector matrix V is orthogonal. + I.e. A = V*D*V' and V*VT=I. + If A is not symmetric, then the eigenvalue matrix D is block diagonal + with the real eigenvalues in 1-by-1 blocks and any complex eigenvalues, + lambda + i*mu, in 2-by-2 blocks, [lambda, mu; -mu, lambda]. The + columns of V represent the eigenvectors in the sense that A*V = V*D, + i.e. A.Multiply(V) equals V.Multiply(D). The matrix V may be badly + conditioned, or even singular, so the validity of the equation + A = V*D*Inverse(V) depends upon V.Condition(). + + + + + Initializes a new instance of the class. This object will compute the + the eigenvalue decomposition when the constructor is called and cache it's decomposition. + + The matrix to factor. + If it is known whether the matrix is symmetric or not the routine can skip checking it itself. + If is null. + If EVD algorithm failed to converge with matrix . + + + + Solves a system of linear equations, AX = B, with A SVD factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A EVD factorized. + + The right hand side vector, b. + The left hand side , x. + + + + A class which encapsulates the functionality of the QR decomposition Modified Gram-Schmidt Orthogonalization. + Any real square matrix A may be decomposed as A = QR where Q is an orthogonal mxn matrix and R is an nxn upper triangular matrix. + + + The computation of the QR decomposition is done at construction time by modified Gram-Schmidt Orthogonalization. + + + + + Initializes a new instance of the class. This object creates an orthogonal matrix + using the modified Gram-Schmidt method. + + The matrix to factor. + If is null. + If row count is less then column count + If is rank deficient + + + + Factorize matrix using the modified Gram-Schmidt method. + + Initial matrix. On exit is replaced by Q. + Number of rows in Q. + Number of columns in Q. + On exit is filled by R. + + + + Solves a system of linear equations, AX = B, with A QR factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A QR factorized. + + The right hand side vector, b. + The left hand side , x. + + + + A class which encapsulates the functionality of an LU factorization. + For a matrix A, the LU factorization is a pair of lower triangular matrix L and + upper triangular matrix U so that A = L*U. + + + The computation of the LU factorization is done at construction time. + + + + + Initializes a new instance of the class. This object will compute the + LU factorization when the constructor is called and cache it's factorization. + + The matrix to factor. + If is null. + If is not a square matrix. + + + + Solves a system of linear equations, AX = B, with A LU factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A LU factorized. + + The right hand side vector, b. + The left hand side , x. + + + + Returns the inverse of this matrix. The inverse is calculated using LU decomposition. + + The inverse of this matrix. + + + + A class which encapsulates the functionality of the QR decomposition. + Any real square matrix A may be decomposed as A = QR where Q is an orthogonal matrix + (its columns are orthogonal unit vectors meaning QTQ = I) and R is an upper triangular matrix + (also called right triangular matrix). + + + The computation of the QR decomposition is done at construction time by Householder transformation. + + + + + Gets or sets Tau vector. Contains additional information on Q - used for native solver. + + + + + Initializes a new instance of the class. This object will compute the + QR factorization when the constructor is called and cache it's factorization. + + The matrix to factor. + The QR factorization method to use. + If is null. + If row count is less then column count + + + + Solves a system of linear equations, AX = B, with A QR factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A QR factorized. + + The right hand side vector, b. + The left hand side , x. + + + + A class which encapsulates the functionality of the singular value decomposition (SVD) for . + Suppose M is an m-by-n matrix whose entries are real numbers. + Then there exists a factorization of the form M = UΣVT where: + - U is an m-by-m unitary matrix; + - Σ is m-by-n diagonal matrix with nonnegative real numbers on the diagonal; + - VT denotes transpose of V, an n-by-n unitary matrix; + Such a factorization is called a singular-value decomposition of M. A common convention is to order the diagonal + entries Σ(i,i) in descending order. In this case, the diagonal matrix Σ is uniquely determined + by M (though the matrices U and V are not). The diagonal entries of Σ are known as the singular values of M. + + + The computation of the singular value decomposition is done at construction time. + + + + + Initializes a new instance of the class. This object will compute the + the singular value decomposition when the constructor is called and cache it's decomposition. + + The matrix to factor. + Compute the singular U and VT vectors or not. + If is null. + If SVD algorithm failed to converge with matrix . + + + + Solves a system of linear equations, AX = B, with A SVD factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A SVD factorized. + + The right hand side vector, b. + The left hand side , x. + + + + Eigenvalues and eigenvectors of a real matrix. + + + If A is symmetric, then A = V*D*V' where the eigenvalue matrix D is + diagonal and the eigenvector matrix V is orthogonal. + I.e. A = V*D*V' and V*VT=I. + If A is not symmetric, then the eigenvalue matrix D is block diagonal + with the real eigenvalues in 1-by-1 blocks and any complex eigenvalues, + lambda + i*mu, in 2-by-2 blocks, [lambda, mu; -mu, lambda]. The + columns of V represent the eigenvectors in the sense that A*V = V*D, + i.e. A.Multiply(V) equals V.Multiply(D). The matrix V may be badly + conditioned, or even singular, so the validity of the equation + A = V*D*Inverse(V) depends upon V.Condition(). + + + + + Gets the absolute value of determinant of the square matrix for which the EVD was computed. + + + + + Gets the effective numerical matrix rank. + + The number of non-negligible singular values. + + + + Gets a value indicating whether the matrix is full rank or not. + + true if the matrix is full rank; otherwise false. + + + + A class which encapsulates the functionality of the QR decomposition Modified Gram-Schmidt Orthogonalization. + Any real square matrix A may be decomposed as A = QR where Q is an orthogonal mxn matrix and R is an nxn upper triangular matrix. + + + The computation of the QR decomposition is done at construction time by modified Gram-Schmidt Orthogonalization. + + + + + Gets the absolute determinant value of the matrix for which the QR matrix was computed. + + + + + Gets a value indicating whether the matrix is full rank or not. + + true if the matrix is full rank; otherwise false. + + + + A class which encapsulates the functionality of an LU factorization. + For a matrix A, the LU factorization is a pair of lower triangular matrix L and + upper triangular matrix U so that A = L*U. + In the Math.NET implementation we also store a set of pivot elements for increased + numerical stability. The pivot elements encode a permutation matrix P such that P*A = L*U. + + + The computation of the LU factorization is done at construction time. + + + + + Gets the determinant of the matrix for which the LU factorization was computed. + + + + + A class which encapsulates the functionality of the QR decomposition. + Any real square matrix A (m x n) may be decomposed as A = QR where Q is an orthogonal matrix + (its columns are orthogonal unit vectors meaning QTQ = I) and R is an upper triangular matrix + (also called right triangular matrix). + + + The computation of the QR decomposition is done at construction time by Householder transformation. + If a factorization is performed, the resulting Q matrix is an m x m matrix + and the R matrix is an m x n matrix. If a factorization is performed, the + resulting Q matrix is an m x n matrix and the R matrix is an n x n matrix. + + + + + Gets the absolute determinant value of the matrix for which the QR matrix was computed. + + + + + Gets a value indicating whether the matrix is full rank or not. + + true if the matrix is full rank; otherwise false. + + + + A class which encapsulates the functionality of the singular value decomposition (SVD). + Suppose M is an m-by-n matrix whose entries are real numbers. + Then there exists a factorization of the form M = UΣVT where: + - U is an m-by-m unitary matrix; + - Σ is m-by-n diagonal matrix with nonnegative real numbers on the diagonal; + - VT denotes transpose of V, an n-by-n unitary matrix; + Such a factorization is called a singular-value decomposition of M. A common convention is to order the diagonal + entries Σ(i,i) in descending order. In this case, the diagonal matrix Σ is uniquely determined + by M (though the matrices U and V are not). The diagonal entries of Σ are known as the singular values of M. + + + The computation of the singular value decomposition is done at construction time. + + + + + Gets the effective numerical matrix rank. + + The number of non-negligible singular values. + + + + Gets the two norm of the . + + The 2-norm of the . + + + + Gets the condition number max(S) / min(S) + + The condition number. + + + + Gets the determinant of the square matrix for which the SVD was computed. + + + + + A class which encapsulates the functionality of a Cholesky factorization for user matrices. + For a symmetric, positive definite matrix A, the Cholesky factorization + is an lower triangular matrix L so that A = L*L'. + + + The computation of the Cholesky factorization is done at construction time. If the matrix is not symmetric + or positive definite, the constructor will throw an exception. + + + + + Computes the Cholesky factorization in-place. + + On entry, the matrix to factor. On exit, the Cholesky factor matrix + If is null. + If is not a square matrix. + If is not positive definite. + + + + Initializes a new instance of the class. This object will compute the + Cholesky factorization when the constructor is called and cache it's factorization. + + The matrix to factor. + If is null. + If is not a square matrix. + If is not positive definite. + + + + Calculates the Cholesky factorization of the input matrix. + + The matrix to be factorized. + If is null. + If is not a square matrix. + If is not positive definite. + If does not have the same dimensions as the existing factor. + + + + Calculate Cholesky step + + Factor matrix + Number of rows + Column start + Total columns + Multipliers calculated previously + Number of available processors + + + + Solves a system of linear equations, AX = B, with A Cholesky factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A Cholesky factorized. + + The right hand side vector, b. + The left hand side , x. + + + + Eigenvalues and eigenvectors of a real matrix. + + + If A is symmetric, then A = V*D*V' where the eigenvalue matrix D is + diagonal and the eigenvector matrix V is orthogonal. + I.e. A = V*D*V' and V*VT=I. + If A is not symmetric, then the eigenvalue matrix D is block diagonal + with the real eigenvalues in 1-by-1 blocks and any complex eigenvalues, + lambda + i*mu, in 2-by-2 blocks, [lambda, mu; -mu, lambda]. The + columns of V represent the eigenvectors in the sense that A*V = V*D, + i.e. A.Multiply(V) equals V.Multiply(D). The matrix V may be badly + conditioned, or even singular, so the validity of the equation + A = V*D*Inverse(V) depends upon V.Condition(). + + + + + Initializes a new instance of the class. This object will compute the + the eigenvalue decomposition when the constructor is called and cache it's decomposition. + + The matrix to factor. + If it is known whether the matrix is symmetric or not the routine can skip checking it itself. + If is null. + If EVD algorithm failed to converge with matrix . + + + + Symmetric Householder reduction to tridiagonal form. + + The eigen vectors to work on. + Arrays for internal storage of real parts of eigenvalues + Arrays for internal storage of imaginary parts of eigenvalues + Order of initial matrix + This is derived from the Algol procedures tred2 by + Bowdler, Martin, Reinsch, and Wilkinson, Handbook for + Auto. Comp., Vol.ii-Linear Algebra, and the corresponding + Fortran subroutine in EISPACK. + + + + Symmetric tridiagonal QL algorithm. + + The eigen vectors to work on. + Arrays for internal storage of real parts of eigenvalues + Arrays for internal storage of imaginary parts of eigenvalues + Order of initial matrix + This is derived from the Algol procedures tql2, by + Bowdler, Martin, Reinsch, and Wilkinson, Handbook for + Auto. Comp., Vol.ii-Linear Algebra, and the corresponding + Fortran subroutine in EISPACK. + + + + + Nonsymmetric reduction to Hessenberg form. + + The eigen vectors to work on. + Array for internal storage of nonsymmetric Hessenberg form. + Order of initial matrix + This is derived from the Algol procedures orthes and ortran, + by Martin and Wilkinson, Handbook for Auto. Comp., + Vol.ii-Linear Algebra, and the corresponding + Fortran subroutines in EISPACK. + + + + Nonsymmetric reduction from Hessenberg to real Schur form. + + The eigen vectors to work on. + Array for internal storage of nonsymmetric Hessenberg form. + Arrays for internal storage of real parts of eigenvalues + Arrays for internal storage of imaginary parts of eigenvalues + Order of initial matrix + This is derived from the Algol procedure hqr2, + by Martin and Wilkinson, Handbook for Auto. Comp., + Vol.ii-Linear Algebra, and the corresponding + Fortran subroutine in EISPACK. + + + + Complex scalar division X/Y. + + Real part of X + Imaginary part of X + Real part of Y + Imaginary part of Y + Division result as a number. + + + + Solves a system of linear equations, AX = B, with A SVD factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A EVD factorized. + + The right hand side vector, b. + The left hand side , x. + + + + A class which encapsulates the functionality of the QR decomposition Modified Gram-Schmidt Orthogonalization. + Any real square matrix A may be decomposed as A = QR where Q is an orthogonal mxn matrix and R is an nxn upper triangular matrix. + + + The computation of the QR decomposition is done at construction time by modified Gram-Schmidt Orthogonalization. + + + + + Initializes a new instance of the class. This object creates an orthogonal matrix + using the modified Gram-Schmidt method. + + The matrix to factor. + If is null. + If row count is less then column count + If is rank deficient + + + + Solves a system of linear equations, AX = B, with A QR factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A QR factorized. + + The right hand side vector, b. + The left hand side , x. + + + + A class which encapsulates the functionality of an LU factorization. + For a matrix A, the LU factorization is a pair of lower triangular matrix L and + upper triangular matrix U so that A = L*U. + + + The computation of the LU factorization is done at construction time. + + + + + Initializes a new instance of the class. This object will compute the + LU factorization when the constructor is called and cache it's factorization. + + The matrix to factor. + If is null. + If is not a square matrix. + + + + Solves a system of linear equations, AX = B, with A LU factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A LU factorized. + + The right hand side vector, b. + The left hand side , x. + + + + Returns the inverse of this matrix. The inverse is calculated using LU decomposition. + + The inverse of this matrix. + + + + A class which encapsulates the functionality of the QR decomposition. + Any real square matrix A may be decomposed as A = QR where Q is an orthogonal matrix + (its columns are orthogonal unit vectors meaning QTQ = I) and R is an upper triangular matrix + (also called right triangular matrix). + + + The computation of the QR decomposition is done at construction time by Householder transformation. + + + + + Initializes a new instance of the class. This object will compute the + QR factorization when the constructor is called and cache it's factorization. + + The matrix to factor. + The QR factorization method to use. + If is null. + + + + Generate column from initial matrix to work array + + Initial matrix + The first row + Column index + Generated vector + + + + Perform calculation of Q or R + + Work array + Q or R matrices + The first row + The last row + The first column + The last column + Number of available CPUs + + + + Solves a system of linear equations, AX = B, with A QR factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A QR factorized. + + The right hand side vector, b. + The left hand side , x. + + + + A class which encapsulates the functionality of the singular value decomposition (SVD) for . + Suppose M is an m-by-n matrix whose entries are real numbers. + Then there exists a factorization of the form M = UΣVT where: + - U is an m-by-m unitary matrix; + - Σ is m-by-n diagonal matrix with nonnegative real numbers on the diagonal; + - VT denotes transpose of V, an n-by-n unitary matrix; + Such a factorization is called a singular-value decomposition of M. A common convention is to order the diagonal + entries Σ(i,i) in descending order. In this case, the diagonal matrix Σ is uniquely determined + by M (though the matrices U and V are not). The diagonal entries of Σ are known as the singular values of M. + + + The computation of the singular value decomposition is done at construction time. + + + + + Initializes a new instance of the class. This object will compute the + the singular value decomposition when the constructor is called and cache it's decomposition. + + The matrix to factor. + Compute the singular U and VT vectors or not. + If is null. + + + + + Calculates absolute value of multiplied on signum function of + + Double value z1 + Double value z2 + Result multiplication of signum function and absolute value + + + + Swap column and + + Source matrix + The number of rows in + Column A index to swap + Column B index to swap + + + + Scale column by starting from row + + Source matrix + The number of rows in + Column to scale + Row to scale from + Scale value + + + + Scale vector by starting from index + + Source vector + Row to scale from + Scale value + + + + Given the Cartesian coordinates (da, db) of a point p, these function return the parameters da, db, c, and s + associated with the Givens rotation that zeros the y-coordinate of the point. + + Provides the x-coordinate of the point p. On exit contains the parameter r associated with the Givens rotation + Provides the y-coordinate of the point p. On exit contains the parameter z associated with the Givens rotation + Contains the parameter c associated with the Givens rotation + Contains the parameter s associated with the Givens rotation + This is equivalent to the DROTG LAPACK routine. + + + + Calculate Norm 2 of the column in matrix starting from row + + Source matrix + The number of rows in + Column index + Start row index + Norm2 (Euclidean norm) of the column + + + + Calculate Norm 2 of the vector starting from index + + Source vector + Start index + Norm2 (Euclidean norm) of the vector + + + + Calculate dot product of and + + Source matrix + The number of rows in + Index of column A + Index of column B + Starting row index + Dot product value + + + + Performs rotation of points in the plane. Given two vectors x and y , + each vector element of these vectors is replaced as follows: x(i) = c*x(i) + s*y(i); y(i) = c*y(i) - s*x(i) + + Source matrix + The number of rows in + Index of column A + Index of column B + Scalar "c" value + Scalar "s" value + + + + Solves a system of linear equations, AX = B, with A SVD factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A SVD factorized. + + The right hand side vector, b. + The left hand side , x. + + + + float version of the class. + + + + + Initializes a new instance of the Matrix class. + + + + + Set all values whose absolute value is smaller than the threshold to zero. + + + + + Returns the conjugate transpose of this matrix. + + The conjugate transpose of this matrix. + + + + Puts the conjugate transpose of this matrix into the result matrix. + + + + + Complex conjugates each element of this matrix and place the results into the result matrix. + + The result of the conjugation. + + + + Negate each element of this matrix and place the results into the result matrix. + + The result of the negation. + + + + Add a scalar to each element of the matrix and stores the result in the result vector. + + The scalar to add. + The matrix to store the result of the addition. + + + + Adds another matrix to this matrix. + + The matrix to add to this matrix. + The matrix to store the result of the addition. + If the other matrix is . + If the two matrices don't have the same dimensions. + + + + Subtracts a scalar from each element of the vector and stores the result in the result vector. + + The scalar to subtract. + The matrix to store the result of the subtraction. + + + + Subtracts another matrix from this matrix. + + The matrix to subtract to this matrix. + The matrix to store the result of subtraction. + If the other matrix is . + If the two matrices don't have the same dimensions. + + + + Multiplies each element of the matrix by a scalar and places results into the result matrix. + + The scalar to multiply the matrix with. + The matrix to store the result of the multiplication. + + + + Multiplies this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + + + + Multiplies this matrix with another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Divides each element of the matrix by a scalar and places results into the result matrix. + + The scalar to divide the matrix with. + The matrix to store the result of the division. + + + + Divides a scalar by each element of the matrix and stores the result in the result matrix. + + The scalar to divide by each element of the matrix. + The matrix to store the result of the division. + + + + Multiplies this matrix with transpose of another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies this matrix with the conjugate transpose of another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies the transpose of this matrix with another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies the transpose of this matrix with another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies the transpose of this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + + + + Multiplies the conjugate transpose of this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + + + + Computes the canonical modulus, where the result has the sign of the divisor, + for the given divisor each element of the matrix. + + The scalar denominator to use. + Matrix to store the results in. + + + + Computes the canonical modulus, where the result has the sign of the divisor, + for the given dividend for each element of the matrix. + + The scalar numerator to use. + A vector to store the results in. + + + + Computes the remainder (% operator), where the result has the sign of the dividend, + for the given divisor each element of the matrix. + + The scalar denominator to use. + Matrix to store the results in. + + + + Computes the remainder (% operator), where the result has the sign of the dividend, + for the given dividend for each element of the matrix. + + The scalar numerator to use. + A vector to store the results in. + + + + Pointwise multiplies this matrix with another matrix and stores the result into the result matrix. + + The matrix to pointwise multiply with this one. + The matrix to store the result of the pointwise multiplication. + + + + Pointwise divide this matrix by another matrix and stores the result into the result matrix. + + The matrix to pointwise divide this one by. + The matrix to store the result of the pointwise division. + + + + Pointwise raise this matrix to an exponent and store the result into the result matrix. + + The exponent to raise this matrix values to. + The matrix to store the result of the pointwise power. + + + + Pointwise raise this matrix to an exponent and store the result into the result matrix. + + The exponent to raise this matrix values to. + The vector to store the result of the pointwise power. + + + + Pointwise canonical modulus, where the result has the sign of the divisor, + of this matrix with another matrix and stores the result into the result matrix. + + The pointwise denominator matrix to use + The result of the modulus. + + + + Pointwise remainder (% operator), where the result has the sign of the dividend, + of this matrix with another matrix and stores the result into the result matrix. + + The pointwise denominator matrix to use + The result of the modulus. + + + + Pointwise applies the exponential function to each value and stores the result into the result matrix. + + The matrix to store the result. + + + + Pointwise applies the natural logarithm function to each value and stores the result into the result matrix. + + The matrix to store the result. + + + + Computes the Moore-Penrose Pseudo-Inverse of this matrix. + + + + + Computes the trace of this matrix. + + The trace of this matrix + If the matrix is not square + + + Calculates the induced L1 norm of this matrix. + The maximum absolute column sum of the matrix. + + + Calculates the induced infinity norm of this matrix. + The maximum absolute row sum of the matrix. + + + Calculates the entry-wise Frobenius norm of this matrix. + The square root of the sum of the squared values. + + + + Calculates the p-norms of all row vectors. + Typical values for p are 1.0 (L1, Manhattan norm), 2.0 (L2, Euclidean norm) and positive infinity (infinity norm) + + + + + Calculates the p-norms of all column vectors. + Typical values for p are 1.0 (L1, Manhattan norm), 2.0 (L2, Euclidean norm) and positive infinity (infinity norm) + + + + + Normalizes all row vectors to a unit p-norm. + Typical values for p are 1.0 (L1, Manhattan norm), 2.0 (L2, Euclidean norm) and positive infinity (infinity norm) + + + + + Normalizes all column vectors to a unit p-norm. + Typical values for p are 1.0 (L1, Manhattan norm), 2.0 (L2, Euclidean norm) and positive infinity (infinity norm) + + + + + Calculates the value sum of each row vector. + + + + + Calculates the absolute value sum of each row vector. + + + + + Calculates the value sum of each column vector. + + + + + Calculates the absolute value sum of each column vector. + + + + + Evaluates whether this matrix is Hermitian (conjugate symmetric). + + + + + A Bi-Conjugate Gradient stabilized iterative matrix solver. + + + + The Bi-Conjugate Gradient Stabilized (BiCGStab) solver is an 'improvement' + of the standard Conjugate Gradient (CG) solver. Unlike the CG solver the + BiCGStab can be used on non-symmetric matrices.
    + Note that much of the success of the solver depends on the selection of the + proper preconditioner. +     + + The Bi-CGSTAB algorithm was taken from:
    + Templates for the solution of linear systems: Building blocks + for iterative methods +
    + Richard Barrett, Michael Berry, Tony F. Chan, James Demmel, + June M. Donato, Jack Dongarra, Victor Eijkhout, Roldan Pozo, + Charles Romine and Henk van der Vorst +
    + Url: http://www.netlib.org/templates/Templates.html +
    + Algorithm is described in Chapter 2, section 2.3.8, page 27 +     + + The example code below provides an indication of the possible use of the + solver. + +     +     + + + Calculates the true residual of the matrix equation Ax = b according to: residual = b - Ax + + Instance of the A. + Residual values in . + Instance of the x. + Instance of the b. + + + + Solves the matrix equation Ax = b, where A is the coefficient matrix, b is the + solution vector and x is the unknown vector. + + The coefficient , A. + The solution , b. + The result , x. + The iterator to use to control when to stop iterating. + The preconditioner to use for approximations. + + + + A composite matrix solver. The actual solver is made by a sequence of + matrix solvers. + + + + Solver based on:
    + Faster PDE-based simulations using robust composite linear solvers
    + S. Bhowmicka, P. Raghavan a,*, L. McInnes b, B. Norris
    + Future Generation Computer Systems, Vol 20, 2004, pp 373�387
    +     + + Note that if an iterator is passed to this solver it will be used for all the sub-solvers. + +     +     + + + The collection of solvers that will be used + + + + + Solves the matrix equation Ax = b, where A is the coefficient matrix, b is the + solution vector and x is the unknown vector. + + The coefficient matrix, A. + The solution vector, b + The result vector, x + The iterator to use to control when to stop iterating. + The preconditioner to use for approximations. + + + + A diagonal preconditioner. The preconditioner uses the inverse + of the matrix diagonal as preconditioning values. + + + + + The inverse of the matrix diagonal. + + + + + Returns the decomposed matrix diagonal. + + The matrix diagonal. + + + + Initializes the preconditioner and loads the internal data structures. + + + The upon which this preconditioner is based. + If is . + If is not a square matrix. + + + + Approximates the solution to the matrix equation Ax = b. + + The right hand side vector. + The left hand side vector. Also known as the result vector. + + + + A Generalized Product Bi-Conjugate Gradient iterative matrix solver. + + + + The Generalized Product Bi-Conjugate Gradient (GPBiCG) solver is an + alternative version of the Bi-Conjugate Gradient stabilized (CG) solver. + Unlike the CG solver the GPBiCG solver can be used on + non-symmetric matrices.
    + Note that much of the success of the solver depends on the selection of the + proper preconditioner. +     + + The GPBiCG algorithm was taken from:
    + GPBiCG(m,l): A hybrid of BiCGSTAB and GPBiCG methods with + efficiency and robustness +
    + S. Fujino +
    + Applied Numerical Mathematics, Volume 41, 2002, pp 107 - 117 +
    +     + + The example code below provides an indication of the possible use of the + solver. + +     +     + + + Indicates the number of BiCGStab steps should be taken + before switching. + + + + + Indicates the number of GPBiCG steps should be taken + before switching. + + + + + Gets or sets the number of steps taken with the BiCgStab algorithm + before switching over to the GPBiCG algorithm. + + + + + Gets or sets the number of steps taken with the GPBiCG algorithm + before switching over to the BiCgStab algorithm. + + + + + Calculates the true residual of the matrix equation Ax = b according to: residual = b - Ax + + Instance of the A. + Residual values in . + Instance of the x. + Instance of the b. + + + + Decide if to do steps with BiCgStab + + Number of iteration + true if yes, otherwise false + + + + Solves the matrix equation Ax = b, where A is the coefficient matrix, b is the + solution vector and x is the unknown vector. + + The coefficient matrix, A. + The solution vector, b + The result vector, x + The iterator to use to control when to stop iterating. + The preconditioner to use for approximations. + + + + An incomplete, level 0, LU factorization preconditioner. + + + The ILU(0) algorithm was taken from:
    + Iterative methods for sparse linear systems
    + Yousef Saad
    + Algorithm is described in Chapter 10, section 10.3.2, page 275
    +     +     + + + The matrix holding the lower (L) and upper (U) matrices. The + decomposition matrices are combined to reduce storage. + + + + + Returns the upper triagonal matrix that was created during the LU decomposition. + + A new matrix containing the upper triagonal elements. + + + + Returns the lower triagonal matrix that was created during the LU decomposition. + + A new matrix containing the lower triagonal elements. + + + + Initializes the preconditioner and loads the internal data structures. + + The matrix upon which the preconditioner is based. + If is . + If is not a square matrix. + + + + Approximates the solution to the matrix equation Ax = b. + + The right hand side vector. + The left hand side vector. Also known as the result vector. + + + + This class performs an Incomplete LU factorization with drop tolerance + and partial pivoting. The drop tolerance indicates which additional entries + will be dropped from the factorized LU matrices. + + + The ILUTP-Mem algorithm was taken from:
    + ILUTP_Mem: a Space-Efficient Incomplete LU Preconditioner +
    + Tzu-Yi Chen, Department of Mathematics and Computer Science,
    + Pomona College, Claremont CA 91711, USA
    + Published in:
    + Lecture Notes in Computer Science
    + Volume 3046 / 2004
    + pp. 20 - 28
    + Algorithm is described in Section 2, page 22 +     +     + + + The default fill level. + + + + + The default drop tolerance. + + + + + The decomposed upper triangular matrix. + + + + + The decomposed lower triangular matrix. + + + + + The array containing the pivot values. + + + + + The fill level. + + + + + The drop tolerance. + + + + + The pivot tolerance. + + + + + Initializes a new instance of the class with the default settings. + + + + + Initializes a new instance of the class with the specified settings. + + + The amount of fill that is allowed in the matrix. The value is a fraction of + the number of non-zero entries in the original matrix. Values should be positive. + + + The absolute drop tolerance which indicates below what absolute value an entry + will be dropped from the matrix. A drop tolerance of 0.0 means that no values + will be dropped. Values should always be positive. + + + The pivot tolerance which indicates at what level pivoting will take place. A + value of 0.0 means that no pivoting will take place. + + + + + Gets or sets the amount of fill that is allowed in the matrix. The + value is a fraction of the number of non-zero entries in the original + matrix. The standard value is 200. + + + + Values should always be positive and can be higher than 1.0. A value lower + than 1.0 means that the eventual preconditioner matrix will have fewer + non-zero entries as the original matrix. A value higher than 1.0 means that + the eventual preconditioner can have more non-zero values than the original + matrix. + + + Note that any changes to the FillLevel after creating the preconditioner + will invalidate the created preconditioner and will require a re-initialization of + the preconditioner. + + + Thrown if a negative value is provided. + + + + Gets or sets the absolute drop tolerance which indicates below what absolute value + an entry will be dropped from the matrix. The standard value is 0.0001. + + + + The values should always be positive and can be larger than 1.0. A low value will + keep more small numbers in the preconditioner matrix. A high value will remove + more small numbers from the preconditioner matrix. + + + Note that any changes to the DropTolerance after creating the preconditioner + will invalidate the created preconditioner and will require a re-initialization of + the preconditioner. + + + Thrown if a negative value is provided. + + + + Gets or sets the pivot tolerance which indicates at what level pivoting will + take place. The standard value is 0.0 which means pivoting will never take place. + + + + The pivot tolerance is used to calculate if pivoting is necessary. Pivoting + will take place if any of the values in a row is bigger than the + diagonal value of that row divided by the pivot tolerance, i.e. pivoting + will take place if row(i,j) > row(i,i) / PivotTolerance for + any j that is not equal to i. + + + Note that any changes to the PivotTolerance after creating the preconditioner + will invalidate the created preconditioner and will require a re-initialization of + the preconditioner. + + + Thrown if a negative value is provided. + + + + Returns the upper triagonal matrix that was created during the LU decomposition. + + + This method is used for debugging purposes only and should normally not be used. + + A new matrix containing the upper triagonal elements. + + + + Returns the lower triagonal matrix that was created during the LU decomposition. + + + This method is used for debugging purposes only and should normally not be used. + + A new matrix containing the lower triagonal elements. + + + + Returns the pivot array. This array is not needed for normal use because + the preconditioner will return the solution vector values in the proper order. + + + This method is used for debugging purposes only and should normally not be used. + + The pivot array. + + + + Initializes the preconditioner and loads the internal data structures. + + + The upon which this preconditioner is based. Note that the + method takes a general matrix type. However internally the data is stored + as a sparse matrix. Therefore it is not recommended to pass a dense matrix. + + If is . + If is not a square matrix. + + + + Pivot elements in the according to internal pivot array + + Row to pivot in + + + + Was pivoting already performed + + Pivots already done + Current item to pivot + true if performed, otherwise false + + + + Swap columns in the + + Source . + First column index to swap + Second column index to swap + + + + Sort vector descending, not changing vector but placing sorted indices to + + Start sort form + Sort till upper bound + Array with sorted vector indices + Source + + + + Approximates the solution to the matrix equation Ax = b. + + The right hand side vector. + The left hand side vector. Also known as the result vector. + + + + Pivot elements in according to internal pivot array + + Source . + Result after pivoting. + + + + An element sort algorithm for the class. + + + This sort algorithm is used to sort the columns in a sparse matrix based on + the value of the element on the diagonal of the matrix. + + + + + Sorts the elements of the vector in decreasing + fashion. The vector itself is not affected. + + The starting index. + The stopping index. + An array that will contain the sorted indices once the algorithm finishes. + The that contains the values that need to be sorted. + + + + Sorts the elements of the vector in decreasing + fashion using heap sort algorithm. The vector itself is not affected. + + The starting index. + The stopping index. + An array that will contain the sorted indices once the algorithm finishes. + The that contains the values that need to be sorted. + + + + Build heap for double indices + + Root position + Length of + Indices of + Target + + + + Sift double indices + + Indices of + Target + Root position + Length of + + + + Sorts the given integers in a decreasing fashion. + + The values. + + + + Sort the given integers in a decreasing fashion using heapsort algorithm + + Array of values to sort + Length of + + + + Build heap + + Target values array + Root position + Length of + + + + Sift values + + Target value array + Root position + Length of + + + + Exchange values in array + + Target values array + First value to exchange + Second value to exchange + + + + A simple milu(0) preconditioner. + + + Original Fortran code by Yousef Saad (07 January 2004) + + + + Use modified or standard ILU(0) + + + + Gets or sets a value indicating whether to use modified or standard ILU(0). + + + + + Gets a value indicating whether the preconditioner is initialized. + + + + + Initializes the preconditioner and loads the internal data structures. + + The matrix upon which the preconditioner is based. + If is . + If is not a square or is not an + instance of SparseCompressedRowMatrixStorage. + + + + Approximates the solution to the matrix equation Ax = b. + + The right hand side vector b. + The left hand side vector x. + + + + MILU0 is a simple milu(0) preconditioner. + + Order of the matrix. + Matrix values in CSR format (input). + Column indices (input). + Row pointers (input). + Matrix values in MSR format (output). + Row pointers and column indices (output). + Pointer to diagonal elements (output). + True if the modified/MILU algorithm should be used (recommended) + Returns 0 on success or k > 0 if a zero pivot was encountered at step k. + + + + A Multiple-Lanczos Bi-Conjugate Gradient stabilized iterative matrix solver. + + + + The Multiple-Lanczos Bi-Conjugate Gradient stabilized (ML(k)-BiCGStab) solver is an 'improvement' + of the standard BiCgStab solver. + + + The algorithm was taken from:
    + ML(k)BiCGSTAB: A BiCGSTAB variant based on multiple Lanczos starting vectors +
    + Man-Chung Yeung and Tony F. Chan +
    + SIAM Journal of Scientific Computing +
    + Volume 21, Number 4, pp. 1263 - 1290 +     + + The example code below provides an indication of the possible use of the + solver. + +     +     + + + The default number of starting vectors. + + + + + The collection of starting vectors which are used as the basis for the Krylov sub-space. + + + + + The number of starting vectors used by the algorithm + + + + + Gets or sets the number of starting vectors. + + + Must be larger than 1 and smaller than the number of variables in the matrix that + for which this solver will be used. + + + + + Resets the number of starting vectors to the default value. + + + + + Gets or sets a series of orthonormal vectors which will be used as basis for the + Krylov sub-space. + + + + + Gets the number of starting vectors to create + + Maximum number + Number of variables + Number of starting vectors to create + + + + Returns an array of starting vectors. + + The maximum number of starting vectors that should be created. + The number of variables. + + An array with starting vectors. The array will never be larger than the + but it may be smaller if + the is smaller than + the . + + + + + Create random vectors array + + Number of vectors + Size of each vector + Array of random vectors + + + + Calculates the true residual of the matrix equation Ax = b according to: residual = b - Ax + + Source A. + Residual data. + x data. + b data. + + + + Solves the matrix equation Ax = b, where A is the coefficient matrix, b is the + solution vector and x is the unknown vector. + + The coefficient matrix, A. + The solution vector, b + The result vector, x + The iterator to use to control when to stop iterating. + The preconditioner to use for approximations. + + + + A Transpose Free Quasi-Minimal Residual (TFQMR) iterative matrix solver. + + + + The TFQMR algorithm was taken from:
    + Iterative methods for sparse linear systems. +
    + Yousef Saad +
    + Algorithm is described in Chapter 7, section 7.4.3, page 219 +     + + The example code below provides an indication of the possible use of the + solver. + +     +     + + + Calculates the true residual of the matrix equation Ax = b according to: residual = b - Ax + + Instance of the A. + Residual values in . + Instance of the x. + Instance of the b. + + + + Is even? + + Number to check + true if even, otherwise false + + + + Solves the matrix equation Ax = b, where A is the coefficient matrix, b is the + solution vector and x is the unknown vector. + + The coefficient matrix, A. + The solution vector, b + The result vector, x + The iterator to use to control when to stop iterating. + The preconditioner to use for approximations. + + + + A Matrix with sparse storage, intended for very large matrices where most of the cells are zero. + The underlying storage scheme is 3-array compressed-sparse-row (CSR) Format. + Wikipedia - CSR. + + + + + Gets the number of non zero elements in the matrix. + + The number of non zero elements. + + + + Create a new sparse matrix straight from an initialized matrix storage instance. + The storage is used directly without copying. + Intended for advanced scenarios where you're working directly with + storage for performance or interop reasons. + + + + + Create a new square sparse matrix with the given number of rows and columns. + All cells of the matrix will be initialized to zero. + + If the order is less than one. + + + + Create a new sparse matrix with the given number of rows and columns. + All cells of the matrix will be initialized to zero. + + If the row or column count is less than one. + + + + Create a new sparse matrix as a copy of the given other matrix. + This new matrix will be independent from the other matrix. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given two-dimensional array. + This new matrix will be independent from the provided array. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given enumerable. + The enumerable is assumed to be in row-major order (row by row). + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the vector. + + + + + + Create a new sparse matrix with the given number of rows and columns as a copy of the given array. + The array is assumed to be in column-major order (column by column). + This new matrix will be independent from the provided array. + A new memory block will be allocated for storing the matrix. + + + + + + Create a new sparse matrix as a copy of the given enumerable of enumerable columns. + Each enumerable in the master enumerable specifies a column. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given enumerable of enumerable columns. + Each enumerable in the master enumerable specifies a column. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given column arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given column arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given column vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given column vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given enumerable of enumerable rows. + Each enumerable in the master enumerable specifies a row. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given enumerable of enumerable rows. + Each enumerable in the master enumerable specifies a row. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given row arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given row arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given row vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given row vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix with the diagonal as a copy of the given vector. + This new matrix will be independent from the vector. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix with the diagonal as a copy of the given vector. + This new matrix will be independent from the vector. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix with the diagonal as a copy of the given array. + This new matrix will be independent from the array. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix with the diagonal as a copy of the given array. + This new matrix will be independent from the array. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix and initialize each value to the same provided value. + + + + + Create a new sparse matrix and initialize each value using the provided init function. + + + + + Create a new diagonal sparse matrix and initialize each diagonal value to the same provided value. + + + + + Create a new diagonal sparse matrix and initialize each diagonal value using the provided init function. + + + + + Create a new square sparse identity matrix where each diagonal value is set to One. + + + + + Returns a new matrix containing the lower triangle of this matrix. + + The lower triangle of this matrix. + + + + Puts the lower triangle of this matrix into the result matrix. + + Where to store the lower triangle. + If is . + If the result matrix's dimensions are not the same as this matrix. + + + + Puts the lower triangle of this matrix into the result matrix. + + Where to store the lower triangle. + + + + Returns a new matrix containing the upper triangle of this matrix. + + The upper triangle of this matrix. + + + + Puts the upper triangle of this matrix into the result matrix. + + Where to store the lower triangle. + If is . + If the result matrix's dimensions are not the same as this matrix. + + + + Puts the upper triangle of this matrix into the result matrix. + + Where to store the lower triangle. + + + + Returns a new matrix containing the lower triangle of this matrix. The new matrix + does not contain the diagonal elements of this matrix. + + The lower triangle of this matrix. + + + + Puts the strictly lower triangle of this matrix into the result matrix. + + Where to store the lower triangle. + If is . + If the result matrix's dimensions are not the same as this matrix. + + + + Puts the strictly lower triangle of this matrix into the result matrix. + + Where to store the lower triangle. + + + + Returns a new matrix containing the upper triangle of this matrix. The new matrix + does not contain the diagonal elements of this matrix. + + The upper triangle of this matrix. + + + + Puts the strictly upper triangle of this matrix into the result matrix. + + Where to store the lower triangle. + If is . + If the result matrix's dimensions are not the same as this matrix. + + + + Puts the strictly upper triangle of this matrix into the result matrix. + + Where to store the lower triangle. + + + + Negate each element of this matrix and place the results into the result matrix. + + The result of the negation. + + + Calculates the induced infinity norm of this matrix. + The maximum absolute row sum of the matrix. + + + Calculates the entry-wise Frobenius norm of this matrix. + The square root of the sum of the squared values. + + + + Adds another matrix to this matrix. + + The matrix to add to this matrix. + The matrix to store the result of the addition. + If the other matrix is . + If the two matrices don't have the same dimensions. + + + + Subtracts another matrix from this matrix. + + The matrix to subtract to this matrix. + The matrix to store the result of subtraction. + If the other matrix is . + If the two matrices don't have the same dimensions. + + + + Multiplies each element of the matrix by a scalar and places results into the result matrix. + + The scalar to multiply the matrix with. + The matrix to store the result of the multiplication. + + + + Multiplies this matrix with another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + + + + Multiplies this matrix with transpose of another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies the transpose of this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + + + + Pointwise multiplies this matrix with another matrix and stores the result into the result matrix. + + The matrix to pointwise multiply with this one. + The matrix to store the result of the pointwise multiplication. + + + + Pointwise divide this matrix by another matrix and stores the result into the result matrix. + + The matrix to pointwise divide this one by. + The matrix to store the result of the pointwise division. + + + + Computes the canonical modulus, where the result has the sign of the divisor, + for the given divisor each element of the matrix. + + The scalar denominator to use. + Matrix to store the results in. + + + + Computes the remainder (% operator), where the result has the sign of the dividend, + for the given divisor each element of the matrix. + + The scalar denominator to use. + Matrix to store the results in. + + + + Evaluates whether this matrix is symmetric. + + + + + Adds two matrices together and returns the results. + + This operator will allocate new memory for the result. It will + choose the representation of either or depending on which + is denser. + The left matrix to add. + The right matrix to add. + The result of the addition. + If and don't have the same dimensions. + If or is . + + + + Returns a Matrix containing the same values of . + + The matrix to get the values from. + A matrix containing a the same values as . + If is . + + + + Subtracts two matrices together and returns the results. + + This operator will allocate new memory for the result. It will + choose the representation of either or depending on which + is denser. + The left matrix to subtract. + The right matrix to subtract. + The result of the addition. + If and don't have the same dimensions. + If or is . + + + + Negates each element of the matrix. + + The matrix to negate. + A matrix containing the negated values. + If is . + + + + Multiplies a Matrix by a constant and returns the result. + + The matrix to multiply. + The constant to multiply the matrix by. + The result of the multiplication. + If is . + + + + Multiplies a Matrix by a constant and returns the result. + + The matrix to multiply. + The constant to multiply the matrix by. + The result of the multiplication. + If is . + + + + Multiplies two matrices. + + This operator will allocate new memory for the result. It will + choose the representation of either or depending on which + is denser. + The left matrix to multiply. + The right matrix to multiply. + The result of multiplication. + If or is . + If the dimensions of or don't conform. + + + + Multiplies a Matrix and a Vector. + + The matrix to multiply. + The vector to multiply. + The result of multiplication. + If or is . + + + + Multiplies a Vector and a Matrix. + + The vector to multiply. + The matrix to multiply. + The result of multiplication. + If or is . + + + + Multiplies a Matrix by a constant and returns the result. + + The matrix to multiply. + The constant to multiply the matrix by. + The result of the multiplication. + If is . + + + + A vector with sparse storage, intended for very large vectors where most of the cells are zero. + + The sparse vector is not thread safe. + + + + Gets the number of non zero elements in the vector. + + The number of non zero elements. + + + + Create a new sparse vector straight from an initialized vector storage instance. + The storage is used directly without copying. + Intended for advanced scenarios where you're working directly with + storage for performance or interop reasons. + + + + + Create a new sparse vector with the given length. + All cells of the vector will be initialized to zero. + + If length is less than one. + + + + Create a new sparse vector as a copy of the given other vector. + This new vector will be independent from the other vector. + A new memory block will be allocated for storing the vector. + + + + + Create a new sparse vector as a copy of the given enumerable. + This new vector will be independent from the enumerable. + A new memory block will be allocated for storing the vector. + + + + + Create a new sparse vector as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new vector will be independent from the enumerable. + A new memory block will be allocated for storing the vector. + + + + + Create a new sparse vector as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new vector will be independent from the enumerable. + A new memory block will be allocated for storing the vector. + + + + + Create a new sparse vector and initialize each value using the provided value. + + + + + Create a new sparse vector and initialize each value using the provided init function. + + + + + Adds a scalar to each element of the vector and stores the result in the result vector. + Warning, the new 'sparse vector' with a non-zero scalar added to it will be a 100% filled + sparse vector and very inefficient. Would be better to work with a dense vector instead. + + + The scalar to add. + + + The vector to store the result of the addition. + + + + + Adds another vector to this vector and stores the result into the result vector. + + + The vector to add to this one. + + + The vector to store the result of the addition. + + + + + Subtracts a scalar from each element of the vector and stores the result in the result vector. + + + The scalar to subtract. + + + The vector to store the result of the subtraction. + + + + + Subtracts another vector to this vector and stores the result into the result vector. + + + The vector to subtract from this one. + + + The vector to store the result of the subtraction. + + + + + Negates vector and saves result to + + Target vector + + + + Multiplies a scalar to each element of the vector and stores the result in the result vector. + + + The scalar to multiply. + + + The vector to store the result of the multiplication. + + + + + Computes the dot product between this vector and another vector. + + The other vector. + The sum of a[i]*b[i] for all i. + + + + Computes the canonical modulus, where the result has the sign of the divisor, + for each element of the vector for the given divisor. + + The scalar denominator to use. + A vector to store the results in. + + + + Computes the remainder (% operator), where the result has the sign of the dividend, + for each element of the vector for the given divisor. + + The scalar denominator to use. + A vector to store the results in. + + + + Adds two Vectors together and returns the results. + + One of the vectors to add. + The other vector to add. + The result of the addition. + If and are not the same size. + If or is . + + + + Returns a Vector containing the negated values of . + + The vector to get the values from. + A vector containing the negated values as . + If is . + + + + Subtracts two Vectors and returns the results. + + The vector to subtract from. + The vector to subtract. + The result of the subtraction. + If and are not the same size. + If or is . + + + + Multiplies a vector with a scalar. + + The vector to scale. + The scalar value. + The result of the multiplication. + If is . + + + + Multiplies a vector with a scalar. + + The scalar value. + The vector to scale. + The result of the multiplication. + If is . + + + + Computes the dot product between two Vectors. + + The left row vector. + The right column vector. + The dot product between the two vectors. + If and are not the same size. + If or is . + + + + Divides a vector with a scalar. + + The vector to divide. + The scalar value. + The result of the division. + If is . + + + + Computes the remainder (% operator), where the result has the sign of the dividend, + of each element of the vector of the given divisor. + + The vector whose elements we want to compute the modulus of. + The divisor to use, + The result of the calculation + If is . + + + + Returns the index of the absolute minimum element. + + The index of absolute minimum element. + + + + Returns the index of the absolute maximum element. + + The index of absolute maximum element. + + + + Returns the index of the maximum element. + + The index of maximum element. + + + + Returns the index of the minimum element. + + The index of minimum element. + + + + Computes the sum of the vector's elements. + + The sum of the vector's elements. + + + + Calculates the L1 norm of the vector, also known as Manhattan norm. + + The sum of the absolute values. + + + + Calculates the infinity norm of the vector. + + The maximum absolute value. + + + + Computes the p-Norm. + + The p value. + Scalar ret = ( ∑|this[i]|^p )^(1/p) + + + + Pointwise multiplies this vector with another vector and stores the result into the result vector. + + The vector to pointwise multiply with this one. + The vector to store the result of the pointwise multiplication. + + + + Creates a float sparse vector based on a string. The string can be in the following formats (without the + quotes): 'n', 'n,n,..', '(n,n,..)', '[n,n,...]', where n is a float. + + + A float sparse vector containing the values specified by the given string. + + + the string to parse. + + + An that supplies culture-specific formatting information. + + + + + Converts the string representation of a real sparse vector to float-precision sparse vector equivalent. + A return value indicates whether the conversion succeeded or failed. + + + A string containing a real vector to convert. + + + The parsed value. + + + If the conversion succeeds, the result will contain a complex number equivalent to value. + Otherwise the result will be null. + + + + + Converts the string representation of a real sparse vector to float-precision sparse vector equivalent. + A return value indicates whether the conversion succeeded or failed. + + + A string containing a real vector to convert. + + + An that supplies culture-specific formatting information about value. + + + The parsed value. + + + If the conversion succeeds, the result will contain a complex number equivalent to value. + Otherwise the result will be null. + + + + + float version of the class. + + + + + Initializes a new instance of the Vector class. + + + + + Set all values whose absolute value is smaller than the threshold to zero. + + + + + Conjugates vector and save result to + + Target vector + + + + Negates vector and saves result to + + Target vector + + + + Adds a scalar to each element of the vector and stores the result in the result vector. + + + The scalar to add. + + + The vector to store the result of the addition. + + + + + Adds another vector to this vector and stores the result into the result vector. + + + The vector to add to this one. + + + The vector to store the result of the addition. + + + + + Subtracts a scalar from each element of the vector and stores the result in the result vector. + + + The scalar to subtract. + + + The vector to store the result of the subtraction. + + + + + Subtracts another vector to this vector and stores the result into the result vector. + + + The vector to subtract from this one. + + + The vector to store the result of the subtraction. + + + + + Multiplies a scalar to each element of the vector and stores the result in the result vector. + + + The scalar to multiply. + + + The vector to store the result of the multiplication. + + + + + Divides each element of the vector by a scalar and stores the result in the result vector. + + + The scalar to divide with. + + + The vector to store the result of the division. + + + + + Divides a scalar by each element of the vector and stores the result in the result vector. + + The scalar to divide. + The vector to store the result of the division. + + + + Pointwise multiplies this vector with another vector and stores the result into the result vector. + + The vector to pointwise multiply with this one. + The vector to store the result of the pointwise multiplication. + + + + Pointwise divide this vector with another vector and stores the result into the result vector. + + The vector to pointwise divide this one by. + The vector to store the result of the pointwise division. + + + + Pointwise raise this vector to an exponent and store the result into the result vector. + + The exponent to raise this vector values to. + The vector to store the result of the pointwise power. + + + + Pointwise raise this vector to an exponent vector and store the result into the result vector. + + The exponent vector to raise this vector values to. + The vector to store the result of the pointwise power. + + + + Pointwise canonical modulus, where the result has the sign of the divisor, + of this vector with another vector and stores the result into the result vector. + + The pointwise denominator vector to use. + The result of the modulus. + + + + Pointwise remainder (% operator), where the result has the sign of the dividend, + of this vector with another vector and stores the result into the result vector. + + The pointwise denominator vector to use. + The result of the modulus. + + + + Pointwise applies the exponential function to each value and stores the result into the result vector. + + The vector to store the result. + + + + Pointwise applies the natural logarithm function to each value and stores the result into the result vector. + + The vector to store the result. + + + + Computes the dot product between this vector and another vector. + + The other vector. + The sum of a[i]*b[i] for all i. + + + + Computes the dot product between the conjugate of this vector and another vector. + + The other vector. + The sum of conj(a[i])*b[i] for all i. + + + + Computes the canonical modulus, where the result has the sign of the divisor, + for each element of the vector for the given divisor. + + The scalar denominator to use. + A vector to store the results in. + + + + Computes the canonical modulus, where the result has the sign of the divisor, + for the given dividend for each element of the vector. + + The scalar numerator to use. + A vector to store the results in. + + + + Computes the remainder (% operator), where the result has the sign of the dividend, + for each element of the vector for the given divisor. + + The scalar denominator to use. + A vector to store the results in. + + + + Computes the remainder (% operator), where the result has the sign of the dividend, + for the given dividend for each element of the vector. + + The scalar numerator to use. + A vector to store the results in. + + + + Returns the value of the absolute minimum element. + + The value of the absolute minimum element. + + + + Returns the index of the absolute minimum element. + + The index of absolute minimum element. + + + + Returns the value of the absolute maximum element. + + The value of the absolute maximum element. + + + + Returns the index of the absolute maximum element. + + The index of absolute maximum element. + + + + Computes the sum of the vector's elements. + + The sum of the vector's elements. + + + + Calculates the L1 norm of the vector, also known as Manhattan norm. + + The sum of the absolute values. + + + + Calculates the L2 norm of the vector, also known as Euclidean norm. + + The square root of the sum of the squared values. + + + + Calculates the infinity norm of the vector. + + The maximum absolute value. + + + + Computes the p-Norm. + + + The p value. + + + Scalar ret = ( ∑|At(i)|^p )^(1/p) + + + + + Returns the index of the maximum element. + + The index of maximum element. + + + + Returns the index of the minimum element. + + The index of minimum element. + + + + Normalizes this vector to a unit vector with respect to the p-norm. + + + The p value. + + + This vector normalized to a unit vector with respect to the p-norm. + + + + + A Matrix class with dense storage. The underlying storage is a one dimensional array in column-major order (column by column). + + + + + Number of rows. + + Using this instead of the RowCount property to speed up calculating + a matrix index in the data array. + + + + Number of columns. + + Using this instead of the ColumnCount property to speed up calculating + a matrix index in the data array. + + + + Gets the matrix's data. + + The matrix's data. + + + + Create a new dense matrix straight from an initialized matrix storage instance. + The storage is used directly without copying. + Intended for advanced scenarios where you're working directly with + storage for performance or interop reasons. + + + + + Create a new square dense matrix with the given number of rows and columns. + All cells of the matrix will be initialized to zero. + + If the order is less than one. + + + + Create a new dense matrix with the given number of rows and columns. + All cells of the matrix will be initialized to zero. + + If the row or column count is less than one. + + + + Create a new dense matrix with the given number of rows and columns directly binding to a raw array. + The array is assumed to be in column-major order (column by column) and is used directly without copying. + Very efficient, but changes to the array and the matrix will affect each other. + + + + + + Create a new dense matrix as a copy of the given other matrix. + This new matrix will be independent from the other matrix. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given two-dimensional array. + This new matrix will be independent from the provided array. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given enumerable. + The enumerable is assumed to be in column-major order (column by column). + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given enumerable of enumerable columns. + Each enumerable in the master enumerable specifies a column. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given enumerable of enumerable columns. + Each enumerable in the master enumerable specifies a column. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given column arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given column arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given column vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given column vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given enumerable of enumerable rows. + Each enumerable in the master enumerable specifies a row. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given enumerable of enumerable rows. + Each enumerable in the master enumerable specifies a row. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given row arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given row arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given row vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given row vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix with the diagonal as a copy of the given vector. + This new matrix will be independent from the vector. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix with the diagonal as a copy of the given vector. + This new matrix will be independent from the vector. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix with the diagonal as a copy of the given array. + This new matrix will be independent from the array. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix with the diagonal as a copy of the given array. + This new matrix will be independent from the array. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix and initialize each value to the same provided value. + + + + + Create a new dense matrix and initialize each value using the provided init function. + + + + + Create a new diagonal dense matrix and initialize each diagonal value to the same provided value. + + + + + Create a new diagonal dense matrix and initialize each diagonal value using the provided init function. + + + + + Create a new square sparse identity matrix where each diagonal value is set to One. + + + + + Create a new dense matrix with values sampled from the provided random distribution. + + + + + Gets the matrix's data. + + The matrix's data. + + + Calculates the induced L1 norm of this matrix. + The maximum absolute column sum of the matrix. + + + Calculates the induced infinity norm of this matrix. + The maximum absolute row sum of the matrix. + + + Calculates the entry-wise Frobenius norm of this matrix. + The square root of the sum of the squared values. + + + + Negate each element of this matrix and place the results into the result matrix. + + The result of the negation. + + + + Complex conjugates each element of this matrix and place the results into the result matrix. + + The result of the conjugation. + + + + Add a scalar to each element of the matrix and stores the result in the result vector. + + The scalar to add. + The matrix to store the result of the addition. + + + + Adds another matrix to this matrix. + + The matrix to add to this matrix. + The matrix to store the result of add + If the other matrix is . + If the two matrices don't have the same dimensions. + + + + Subtracts a scalar from each element of the matrix and stores the result in the result vector. + + The scalar to subtract. + The matrix to store the result of the subtraction. + + + + Subtracts another matrix from this matrix. + + The matrix to subtract. + The matrix to store the result of the subtraction. + + + + Multiplies each element of the matrix by a scalar and places results into the result matrix. + + The scalar to multiply the matrix with. + The matrix to store the result of the multiplication. + + + + Multiplies this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + + + + Multiplies this matrix with another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies this matrix with transpose of another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies this matrix with the conjugate transpose of another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies the transpose of this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + + + + Multiplies the conjugate transpose of this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + + + + Multiplies the transpose of this matrix with another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies the transpose of this matrix with another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Divides each element of the matrix by a scalar and places results into the result matrix. + + The scalar to divide the matrix with. + The matrix to store the result of the division. + + + + Pointwise multiplies this matrix with another matrix and stores the result into the result matrix. + + The matrix to pointwise multiply with this one. + The matrix to store the result of the pointwise multiplication. + + + + Pointwise divide this matrix by another matrix and stores the result into the result matrix. + + The matrix to pointwise divide this one by. + The matrix to store the result of the pointwise division. + + + + Pointwise raise this matrix to an exponent and store the result into the result matrix. + + The exponent to raise this matrix values to. + The vector to store the result of the pointwise power. + + + + Computes the trace of this matrix. + + The trace of this matrix + If the matrix is not square + + + + Adds two matrices together and returns the results. + + This operator will allocate new memory for the result. It will + choose the representation of either or depending on which + is denser. + The left matrix to add. + The right matrix to add. + The result of the addition. + If and don't have the same dimensions. + If or is . + + + + Returns a Matrix containing the same values of . + + The matrix to get the values from. + A matrix containing a the same values as . + If is . + + + + Subtracts two matrices together and returns the results. + + This operator will allocate new memory for the result. It will + choose the representation of either or depending on which + is denser. + The left matrix to subtract. + The right matrix to subtract. + The result of the addition. + If and don't have the same dimensions. + If or is . + + + + Negates each element of the matrix. + + The matrix to negate. + A matrix containing the negated values. + If is . + + + + Multiplies a Matrix by a constant and returns the result. + + The matrix to multiply. + The constant to multiply the matrix by. + The result of the multiplication. + If is . + + + + Multiplies a Matrix by a constant and returns the result. + + The matrix to multiply. + The constant to multiply the matrix by. + The result of the multiplication. + If is . + + + + Multiplies two matrices. + + This operator will allocate new memory for the result. It will + choose the representation of either or depending on which + is denser. + The left matrix to multiply. + The right matrix to multiply. + The result of multiplication. + If or is . + If the dimensions of or don't conform. + + + + Multiplies a Matrix and a Vector. + + The matrix to multiply. + The vector to multiply. + The result of multiplication. + If or is . + + + + Multiplies a Vector and a Matrix. + + The vector to multiply. + The matrix to multiply. + The result of multiplication. + If or is . + + + + Multiplies a Matrix by a constant and returns the result. + + The matrix to multiply. + The constant to multiply the matrix by. + The result of the multiplication. + If is . + + + + Evaluates whether this matrix is symmetric. + + + + + Evaluates whether this matrix is Hermitian (conjugate symmetric). + + + + + A vector using dense storage. + + + + + Number of elements + + + + + Gets the vector's data. + + + + + Create a new dense vector straight from an initialized vector storage instance. + The storage is used directly without copying. + Intended for advanced scenarios where you're working directly with + storage for performance or interop reasons. + + + + + Create a new dense vector with the given length. + All cells of the vector will be initialized to zero. + + If length is less than one. + + + + Create a new dense vector directly binding to a raw array. + The array is used directly without copying. + Very efficient, but changes to the array and the vector will affect each other. + + + + + Create a new dense vector as a copy of the given other vector. + This new vector will be independent from the other vector. + A new memory block will be allocated for storing the vector. + + + + + Create a new dense vector as a copy of the given array. + This new vector will be independent from the array. + A new memory block will be allocated for storing the vector. + + + + + Create a new dense vector as a copy of the given enumerable. + This new vector will be independent from the enumerable. + A new memory block will be allocated for storing the vector. + + + + + Create a new dense vector as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new vector will be independent from the enumerable. + A new memory block will be allocated for storing the vector. + + + + + Create a new dense vector as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new vector will be independent from the enumerable. + A new memory block will be allocated for storing the vector. + + + + + Create a new dense vector and initialize each value using the provided value. + + + + + Create a new dense vector and initialize each value using the provided init function. + + + + + Create a new dense vector with values sampled from the provided random distribution. + + + + + Gets the vector's data. + + The vector's data. + + + + Returns a reference to the internal data structure. + + The DenseVector whose internal data we are + returning. + + A reference to the internal date of the given vector. + + + + + Returns a vector bound directly to a reference of the provided array. + + The array to bind to the DenseVector object. + + A DenseVector whose values are bound to the given array. + + + + + Adds a scalar to each element of the vector and stores the result in the result vector. + + The scalar to add. + The vector to store the result of the addition. + + + + Adds another vector to this vector and stores the result into the result vector. + + The vector to add to this one. + The vector to store the result of the addition. + + + + Adds two Vectors together and returns the results. + + One of the vectors to add. + The other vector to add. + The result of the addition. + If and are not the same size. + If or is . + + + + Subtracts a scalar from each element of the vector and stores the result in the result vector. + + The scalar to subtract. + The vector to store the result of the subtraction. + + + + Subtracts another vector from this vector and stores the result into the result vector. + + The vector to subtract from this one. + The vector to store the result of the subtraction. + + + + Returns a Vector containing the negated values of . + + The vector to get the values from. + A vector containing the negated values as . + If is . + + + + Subtracts two Vectors and returns the results. + + The vector to subtract from. + The vector to subtract. + The result of the subtraction. + If and are not the same size. + If or is . + + + + Negates vector and saves result to + + Target vector + + + + Conjugates vector and save result to + + Target vector + + + + Multiplies a scalar to each element of the vector and stores the result in the result vector. + + The scalar to multiply. + The vector to store the result of the multiplication. + + + + + Computes the dot product between this vector and another vector. + + The other vector. + The sum of a[i]*b[i] for all i. + + + + Computes the dot product between the conjugate of this vector and another vector. + + The other vector. + The sum of conj(a[i])*b[i] for all i. + + + + Multiplies a vector with a complex. + + The vector to scale. + The Complex value. + The result of the multiplication. + If is . + + + + Multiplies a vector with a complex. + + The Complex value. + The vector to scale. + The result of the multiplication. + If is . + + + + Computes the dot product between two Vectors. + + The left row vector. + The right column vector. + The dot product between the two vectors. + If and are not the same size. + If or is . + + + + Divides a vector with a complex. + + The vector to divide. + The Complex value. + The result of the division. + If is . + + + + Returns the index of the absolute minimum element. + + The index of absolute minimum element. + + + + Returns the index of the absolute maximum element. + + The index of absolute maximum element. + + + + Computes the sum of the vector's elements. + + The sum of the vector's elements. + + + + Calculates the L1 norm of the vector, also known as Manhattan norm. + + The sum of the absolute values. + + + + Calculates the L2 norm of the vector, also known as Euclidean norm. + + The square root of the sum of the squared values. + + + + Calculates the infinity norm of the vector. + + The maximum absolute value. + + + + Computes the p-Norm. + + The p value. + Scalar ret = ( ∑|this[i]|^p )^(1/p) + + + + Pointwise divide this vector with another vector and stores the result into the result vector. + + The vector to pointwise divide this one by. + The vector to store the result of the pointwise division. + + + + Pointwise divide this vector with another vector and stores the result into the result vector. + + The vector to pointwise divide this one by. + The vector to store the result of the pointwise division. + + + + + Pointwise raise this vector to an exponent vector and store the result into the result vector. + + The exponent vector to raise this vector values to. + The vector to store the result of the pointwise power. + + + + Creates a Complex dense vector based on a string. The string can be in the following formats (without the + quotes): 'n', 'n;n;..', '(n;n;..)', '[n;n;...]', where n is a double. + + + A Complex dense vector containing the values specified by the given string. + + + the string to parse. + + + An that supplies culture-specific formatting information. + + + + + Converts the string representation of a complex dense vector to double-precision dense vector equivalent. + A return value indicates whether the conversion succeeded or failed. + + + A string containing a complex vector to convert. + + + The parsed value. + + + If the conversion succeeds, the result will contain a complex number equivalent to value. + Otherwise the result will be null. + + + + + Converts the string representation of a complex dense vector to double-precision dense vector equivalent. + A return value indicates whether the conversion succeeded or failed. + + + A string containing a complex vector to convert. + + + An that supplies culture-specific formatting information about value. + + + The parsed value. + + + If the conversion succeeds, the result will contain a complex number equivalent to value. + Otherwise the result will be null. + + + + + A matrix type for diagonal matrices. + + + Diagonal matrices can be non-square matrices but the diagonal always starts + at element 0,0. A diagonal matrix will throw an exception if non diagonal + entries are set. The exception to this is when the off diagonal elements are + 0.0 or NaN; these settings will cause no change to the diagonal matrix. + + + + + Gets the matrix's data. + + The matrix's data. + + + + Create a new diagonal matrix straight from an initialized matrix storage instance. + The storage is used directly without copying. + Intended for advanced scenarios where you're working directly with + storage for performance or interop reasons. + + + + + Create a new square diagonal matrix with the given number of rows and columns. + All cells of the matrix will be initialized to zero. + + If the order is less than one. + + + + Create a new diagonal matrix with the given number of rows and columns. + All cells of the matrix will be initialized to zero. + + If the row or column count is less than one. + + + + Create a new diagonal matrix with the given number of rows and columns. + All diagonal cells of the matrix will be initialized to the provided value, all non-diagonal ones to zero. + + If the row or column count is less than one. + + + + Create a new diagonal matrix with the given number of rows and columns directly binding to a raw array. + The array is assumed to contain the diagonal elements only and is used directly without copying. + Very efficient, but changes to the array and the matrix will affect each other. + + + + + Create a new diagonal matrix as a copy of the given other matrix. + This new matrix will be independent from the other matrix. + The matrix to copy from must be diagonal as well. + A new memory block will be allocated for storing the matrix. + + + + + Create a new diagonal matrix as a copy of the given two-dimensional array. + This new matrix will be independent from the provided array. + The array to copy from must be diagonal as well. + A new memory block will be allocated for storing the matrix. + + + + + Create a new diagonal matrix and initialize each diagonal value from the provided indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the matrix. + + + + + Create a new diagonal matrix and initialize each diagonal value from the provided indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the matrix. + + + + + Create a new diagonal matrix and initialize each diagonal value from the provided enumerable. + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the matrix. + + + + + Create a new diagonal matrix and initialize each diagonal value using the provided init function. + + + + + Create a new square sparse identity matrix where each diagonal value is set to One. + + + + + Create a new diagonal matrix with diagonal values sampled from the provided random distribution. + + + + + Negate each element of this matrix and place the results into the result matrix. + + The result of the negation. + + + + Complex conjugates each element of this matrix and place the results into the result matrix. + + The result of the conjugation. + + + + Adds another matrix to this matrix. + + The matrix to add to this matrix. + The matrix to store the result of the addition. + If the two matrices don't have the same dimensions. + + + + Subtracts another matrix from this matrix. + + The matrix to subtract. + The matrix to store the result of the subtraction. + If the two matrices don't have the same dimensions. + + + + Multiplies each element of the matrix by a scalar and places results into the result matrix. + + The scalar to multiply the matrix with. + The matrix to store the result of the multiplication. + If the result matrix's dimensions are not the same as this matrix. + + + + Multiplies this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + + + + Multiplies this matrix with another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies this matrix with transpose of another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies this matrix with the conjugate transpose of another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies the transpose of this matrix with another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies the transpose of this matrix with another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies the transpose of this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + + + + Multiplies the conjugate transpose of this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + + + + Divides each element of the matrix by a scalar and places results into the result matrix. + + The scalar to divide the matrix with. + The matrix to store the result of the division. + + + + Divides a scalar by each element of the matrix and stores the result in the result matrix. + + The scalar to add. + The matrix to store the result of the division. + + + + Computes the determinant of this matrix. + + The determinant of this matrix. + + + + Returns the elements of the diagonal in a . + + The elements of the diagonal. + For non-square matrices, the method returns Min(Rows, Columns) elements where + i == j (i is the row index, and j is the column index). + + + + Copies the values of the given array to the diagonal. + + The array to copy the values from. The length of the vector should be + Min(Rows, Columns). + If the length of does not + equal Min(Rows, Columns). + For non-square matrices, the elements of are copied to + this[i,i]. + + + + Copies the values of the given to the diagonal. + + The vector to copy the values from. The length of the vector should be + Min(Rows, Columns). + If the length of does not + equal Min(Rows, Columns). + For non-square matrices, the elements of are copied to + this[i,i]. + + + Calculates the induced L1 norm of this matrix. + The maximum absolute column sum of the matrix. + + + Calculates the induced L2 norm of the matrix. + The largest singular value of the matrix. + + + Calculates the induced infinity norm of this matrix. + The maximum absolute row sum of the matrix. + + + Calculates the Frobenius norm of this matrix. + The Frobenius norm of this matrix. + + + Calculates the condition number of this matrix. + The condition number of the matrix. + + + Computes the inverse of this matrix. + If is not a square matrix. + If is singular. + The inverse of this matrix. + + + + Returns a new matrix containing the lower triangle of this matrix. + + The lower triangle of this matrix. + + + + Puts the lower triangle of this matrix into the result matrix. + + Where to store the lower triangle. + If the result matrix's dimensions are not the same as this matrix. + + + + Returns a new matrix containing the lower triangle of this matrix. The new matrix + does not contain the diagonal elements of this matrix. + + The lower triangle of this matrix. + + + + Puts the strictly lower triangle of this matrix into the result matrix. + + Where to store the lower triangle. + If the result matrix's dimensions are not the same as this matrix. + + + + Returns a new matrix containing the upper triangle of this matrix. + + The upper triangle of this matrix. + + + + Puts the upper triangle of this matrix into the result matrix. + + Where to store the lower triangle. + If the result matrix's dimensions are not the same as this matrix. + + + + Returns a new matrix containing the upper triangle of this matrix. The new matrix + does not contain the diagonal elements of this matrix. + + The upper triangle of this matrix. + + + + Puts the strictly upper triangle of this matrix into the result matrix. + + Where to store the lower triangle. + If the result matrix's dimensions are not the same as this matrix. + + + + Creates a matrix that contains the values from the requested sub-matrix. + + The row to start copying from. + The number of rows to copy. Must be positive. + The column to start copying from. + The number of columns to copy. Must be positive. + The requested sub-matrix. + If: is + negative, or greater than or equal to the number of rows. + is negative, or greater than or equal to the number + of columns. + (columnIndex + columnLength) >= Columns + (rowIndex + rowLength) >= Rows + If or + is not positive. + + + + Permute the columns of a matrix according to a permutation. + + The column permutation to apply to this matrix. + Always thrown + Permutation in diagonal matrix are senseless, because of matrix nature + + + + Permute the rows of a matrix according to a permutation. + + The row permutation to apply to this matrix. + Always thrown + Permutation in diagonal matrix are senseless, because of matrix nature + + + + Evaluates whether this matrix is symmetric. + + + + + Evaluates whether this matrix is Hermitian (conjugate symmetric). + + + + + A class which encapsulates the functionality of a Cholesky factorization. + For a symmetric, positive definite matrix A, the Cholesky factorization + is an lower triangular matrix L so that A = L*L'. + + + The computation of the Cholesky factorization is done at construction time. If the matrix is not symmetric + or positive definite, the constructor will throw an exception. + + + + + Gets the determinant of the matrix for which the Cholesky matrix was computed. + + + + + Gets the log determinant of the matrix for which the Cholesky matrix was computed. + + + + + A class which encapsulates the functionality of a Cholesky factorization for dense matrices. + For a symmetric, positive definite matrix A, the Cholesky factorization + is an lower triangular matrix L so that A = L*L'. + + + The computation of the Cholesky factorization is done at construction time. If the matrix is not symmetric + or positive definite, the constructor will throw an exception. + + + + + Initializes a new instance of the class. This object will compute the + Cholesky factorization when the constructor is called and cache it's factorization. + + The matrix to factor. + If is null. + If is not a square matrix. + If is not positive definite. + + + + Solves a system of linear equations, AX = B, with A Cholesky factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A Cholesky factorized. + + The right hand side vector, b. + The left hand side , x. + + + + Calculates the Cholesky factorization of the input matrix. + + The matrix to be factorized. + If is null. + If is not a square matrix. + If is not positive definite. + If does not have the same dimensions as the existing factor. + + + + Eigenvalues and eigenvectors of a complex matrix. + + + If A is Hermitian, then A = V*D*V' where the eigenvalue matrix D is + diagonal and the eigenvector matrix V is Hermitian. + I.e. A = V*D*V' and V*VH=I. + If A is not symmetric, then the eigenvalue matrix D is block diagonal + with the real eigenvalues in 1-by-1 blocks and any complex eigenvalues, + lambda + i*mu, in 2-by-2 blocks, [lambda, mu; -mu, lambda]. The + columns of V represent the eigenvectors in the sense that A*V = V*D, + i.e. A.Multiply(V) equals V.Multiply(D). The matrix V may be badly + conditioned, or even singular, so the validity of the equation + A = V*D*Inverse(V) depends upon V.Condition(). + + + + + Initializes a new instance of the class. This object will compute the + the eigenvalue decomposition when the constructor is called and cache it's decomposition. + + The matrix to factor. + If it is known whether the matrix is symmetric or not the routine can skip checking it itself. + If is null. + If EVD algorithm failed to converge with matrix . + + + + Solves a system of linear equations, AX = B, with A SVD factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A EVD factorized. + + The right hand side vector, b. + The left hand side , x. + + + + A class which encapsulates the functionality of the QR decomposition Modified Gram-Schmidt Orthogonalization. + Any complex square matrix A may be decomposed as A = QR where Q is an unitary mxn matrix and R is an nxn upper triangular matrix. + + + The computation of the QR decomposition is done at construction time by modified Gram-Schmidt Orthogonalization. + + + + + Initializes a new instance of the class. This object creates an unitary matrix + using the modified Gram-Schmidt method. + + The matrix to factor. + If is null. + If row count is less then column count + If is rank deficient + + + + Factorize matrix using the modified Gram-Schmidt method. + + Initial matrix. On exit is replaced by Q. + Number of rows in Q. + Number of columns in Q. + On exit is filled by R. + + + + Solves a system of linear equations, AX = B, with A QR factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A QR factorized. + + The right hand side vector, b. + The left hand side , x. + + + + A class which encapsulates the functionality of an LU factorization. + For a matrix A, the LU factorization is a pair of lower triangular matrix L and + upper triangular matrix U so that A = L*U. + + + The computation of the LU factorization is done at construction time. + + + + + Initializes a new instance of the class. This object will compute the + LU factorization when the constructor is called and cache it's factorization. + + The matrix to factor. + If is null. + If is not a square matrix. + + + + Solves a system of linear equations, AX = B, with A LU factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A LU factorized. + + The right hand side vector, b. + The left hand side , x. + + + + Returns the inverse of this matrix. The inverse is calculated using LU decomposition. + + The inverse of this matrix. + + + + A class which encapsulates the functionality of the QR decomposition. + Any real square matrix A may be decomposed as A = QR where Q is an orthogonal matrix + (its columns are orthogonal unit vectors meaning QTQ = I) and R is an upper triangular matrix + (also called right triangular matrix). + + + The computation of the QR decomposition is done at construction time by Householder transformation. + + + + + Gets or sets Tau vector. Contains additional information on Q - used for native solver. + + + + + Initializes a new instance of the class. This object will compute the + QR factorization when the constructor is called and cache it's factorization. + + The matrix to factor. + The type of QR factorization to perform. + If is null. + If row count is less then column count + + + + Solves a system of linear equations, AX = B, with A QR factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A QR factorized. + + The right hand side vector, b. + The left hand side , x. + + + + A class which encapsulates the functionality of the singular value decomposition (SVD) for . + Suppose M is an m-by-n matrix whose entries are real numbers. + Then there exists a factorization of the form M = UΣVT where: + - U is an m-by-m unitary matrix; + - Σ is m-by-n diagonal matrix with nonnegative real numbers on the diagonal; + - VT denotes transpose of V, an n-by-n unitary matrix; + Such a factorization is called a singular-value decomposition of M. A common convention is to order the diagonal + entries Σ(i,i) in descending order. In this case, the diagonal matrix Σ is uniquely determined + by M (though the matrices U and V are not). The diagonal entries of Σ are known as the singular values of M. + + + The computation of the singular value decomposition is done at construction time. + + + + + Initializes a new instance of the class. This object will compute the + the singular value decomposition when the constructor is called and cache it's decomposition. + + The matrix to factor. + Compute the singular U and VT vectors or not. + If is null. + If SVD algorithm failed to converge with matrix . + + + + Solves a system of linear equations, AX = B, with A SVD factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A SVD factorized. + + The right hand side vector, b. + The left hand side , x. + + + + Eigenvalues and eigenvectors of a real matrix. + + + If A is symmetric, then A = V*D*V' where the eigenvalue matrix D is + diagonal and the eigenvector matrix V is orthogonal. + I.e. A = V*D*V' and V*VT=I. + If A is not symmetric, then the eigenvalue matrix D is block diagonal + with the real eigenvalues in 1-by-1 blocks and any complex eigenvalues, + lambda + i*mu, in 2-by-2 blocks, [lambda, mu; -mu, lambda]. The + columns of V represent the eigenvectors in the sense that A*V = V*D, + i.e. A.Multiply(V) equals V.Multiply(D). The matrix V may be badly + conditioned, or even singular, so the validity of the equation + A = V*D*Inverse(V) depends upon V.Condition(). + + + + + Gets the absolute value of determinant of the square matrix for which the EVD was computed. + + + + + Gets the effective numerical matrix rank. + + The number of non-negligible singular values. + + + + Gets a value indicating whether the matrix is full rank or not. + + true if the matrix is full rank; otherwise false. + + + + A class which encapsulates the functionality of the QR decomposition Modified Gram-Schmidt Orthogonalization. + Any real square matrix A may be decomposed as A = QR where Q is an orthogonal mxn matrix and R is an nxn upper triangular matrix. + + + The computation of the QR decomposition is done at construction time by modified Gram-Schmidt Orthogonalization. + + + + + Gets the absolute determinant value of the matrix for which the QR matrix was computed. + + + + + Gets a value indicating whether the matrix is full rank or not. + + true if the matrix is full rank; otherwise false. + + + + A class which encapsulates the functionality of an LU factorization. + For a matrix A, the LU factorization is a pair of lower triangular matrix L and + upper triangular matrix U so that A = L*U. + In the Math.NET implementation we also store a set of pivot elements for increased + numerical stability. The pivot elements encode a permutation matrix P such that P*A = L*U. + + + The computation of the LU factorization is done at construction time. + + + + + Gets the determinant of the matrix for which the LU factorization was computed. + + + + + A class which encapsulates the functionality of the QR decomposition. + Any real square matrix A (m x n) may be decomposed as A = QR where Q is an orthogonal matrix + (its columns are orthogonal unit vectors meaning QTQ = I) and R is an upper triangular matrix + (also called right triangular matrix). + + + The computation of the QR decomposition is done at construction time by Householder transformation. + If a factorization is performed, the resulting Q matrix is an m x m matrix + and the R matrix is an m x n matrix. If a factorization is performed, the + resulting Q matrix is an m x n matrix and the R matrix is an n x n matrix. + + + + + Gets the absolute determinant value of the matrix for which the QR matrix was computed. + + + + + Gets a value indicating whether the matrix is full rank or not. + + true if the matrix is full rank; otherwise false. + + + + A class which encapsulates the functionality of the singular value decomposition (SVD). + Suppose M is an m-by-n matrix whose entries are real numbers. + Then there exists a factorization of the form M = UΣVT where: + - U is an m-by-m unitary matrix; + - Σ is m-by-n diagonal matrix with nonnegative real numbers on the diagonal; + - VT denotes transpose of V, an n-by-n unitary matrix; + Such a factorization is called a singular-value decomposition of M. A common convention is to order the diagonal + entries Σ(i,i) in descending order. In this case, the diagonal matrix Σ is uniquely determined + by M (though the matrices U and V are not). The diagonal entries of Σ are known as the singular values of M. + + + The computation of the singular value decomposition is done at construction time. + + + + + Gets the effective numerical matrix rank. + + The number of non-negligible singular values. + + + + Gets the two norm of the . + + The 2-norm of the . + + + + Gets the condition number max(S) / min(S) + + The condition number. + + + + Gets the determinant of the square matrix for which the SVD was computed. + + + + + A class which encapsulates the functionality of a Cholesky factorization for user matrices. + For a symmetric, positive definite matrix A, the Cholesky factorization + is an lower triangular matrix L so that A = L*L'. + + + The computation of the Cholesky factorization is done at construction time. If the matrix is not symmetric + or positive definite, the constructor will throw an exception. + + + + + Computes the Cholesky factorization in-place. + + On entry, the matrix to factor. On exit, the Cholesky factor matrix + If is null. + If is not a square matrix. + If is not positive definite. + + + + Initializes a new instance of the class. This object will compute the + Cholesky factorization when the constructor is called and cache it's factorization. + + The matrix to factor. + If is null. + If is not a square matrix. + If is not positive definite. + + + + Calculates the Cholesky factorization of the input matrix. + + The matrix to be factorized. + If is null. + If is not a square matrix. + If is not positive definite. + If does not have the same dimensions as the existing factor. + + + + Calculate Cholesky step + + Factor matrix + Number of rows + Column start + Total columns + Multipliers calculated previously + Number of available processors + + + + Solves a system of linear equations, AX = B, with A Cholesky factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A Cholesky factorized. + + The right hand side vector, b. + The left hand side , x. + + + + Eigenvalues and eigenvectors of a complex matrix. + + + If A is Hermitian, then A = V*D*V' where the eigenvalue matrix D is + diagonal and the eigenvector matrix V is Hermitian. + I.e. A = V*D*V' and V*VH=I. + If A is not symmetric, then the eigenvalue matrix D is block diagonal + with the real eigenvalues in 1-by-1 blocks and any complex eigenvalues, + lambda + i*mu, in 2-by-2 blocks, [lambda, mu; -mu, lambda]. The + columns of V represent the eigenvectors in the sense that A*V = V*D, + i.e. A.Multiply(V) equals V.Multiply(D). The matrix V may be badly + conditioned, or even singular, so the validity of the equation + A = V*D*Inverse(V) depends upon V.Condition(). + + + + + Initializes a new instance of the class. This object will compute the + the eigenvalue decomposition when the constructor is called and cache it's decomposition. + + The matrix to factor. + If it is known whether the matrix is symmetric or not the routine can skip checking it itself. + If is null. + If EVD algorithm failed to converge with matrix . + + + + Reduces a complex Hermitian matrix to a real symmetric tridiagonal matrix using unitary similarity transformations. + + Source matrix to reduce + Output: Arrays for internal storage of real parts of eigenvalues + Output: Arrays for internal storage of imaginary parts of eigenvalues + Output: Arrays that contains further information about the transformations. + Order of initial matrix + This is derived from the Algol procedures HTRIDI by + Smith, Boyle, Dongarra, Garbow, Ikebe, Klema, Moler, and Wilkinson, Handbook for + Auto. Comp., Vol.ii-Linear Algebra, and the corresponding + Fortran subroutine in EISPACK. + + + + Symmetric tridiagonal QL algorithm. + + The eigen vectors to work on. + Arrays for internal storage of real parts of eigenvalues + Arrays for internal storage of imaginary parts of eigenvalues + Order of initial matrix + This is derived from the Algol procedures tql2, by + Bowdler, Martin, Reinsch, and Wilkinson, Handbook for + Auto. Comp., Vol.ii-Linear Algebra, and the corresponding + Fortran subroutine in EISPACK. + + + + + Determines eigenvectors by undoing the symmetric tridiagonalize transformation + + The eigen vectors to work on. + Previously tridiagonalized matrix by . + Contains further information about the transformations + Input matrix order + This is derived from the Algol procedures HTRIBK, by + by Smith, Boyle, Dongarra, Garbow, Ikebe, Klema, Moler, and Wilkinson, Handbook for + Auto. Comp., Vol.ii-Linear Algebra, and the corresponding + Fortran subroutine in EISPACK. + + + + Nonsymmetric reduction to Hessenberg form. + + The eigen vectors to work on. + Array for internal storage of nonsymmetric Hessenberg form. + Order of initial matrix + This is derived from the Algol procedures orthes and ortran, + by Martin and Wilkinson, Handbook for Auto. Comp., + Vol.ii-Linear Algebra, and the corresponding + Fortran subroutines in EISPACK. + + + + Nonsymmetric reduction from Hessenberg to real Schur form. + + The eigen vectors to work on. + The eigen values to work on. + Array for internal storage of nonsymmetric Hessenberg form. + Order of initial matrix + This is derived from the Algol procedure hqr2, + by Martin and Wilkinson, Handbook for Auto. Comp., + Vol.ii-Linear Algebra, and the corresponding + Fortran subroutine in EISPACK. + + + + Solves a system of linear equations, AX = B, with A SVD factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A EVD factorized. + + The right hand side vector, b. + The left hand side , x. + + + + A class which encapsulates the functionality of the QR decomposition Modified Gram-Schmidt Orthogonalization. + Any complex square matrix A may be decomposed as A = QR where Q is an unitary mxn matrix and R is an nxn upper triangular matrix. + + + The computation of the QR decomposition is done at construction time by modified Gram-Schmidt Orthogonalization. + + + + + Initializes a new instance of the class. This object creates an unitary matrix + using the modified Gram-Schmidt method. + + The matrix to factor. + If is null. + If row count is less then column count + If is rank deficient + + + + Solves a system of linear equations, AX = B, with A QR factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A QR factorized. + + The right hand side vector, b. + The left hand side , x. + + + + A class which encapsulates the functionality of an LU factorization. + For a matrix A, the LU factorization is a pair of lower triangular matrix L and + upper triangular matrix U so that A = L*U. + + + The computation of the LU factorization is done at construction time. + + + + + Initializes a new instance of the class. This object will compute the + LU factorization when the constructor is called and cache it's factorization. + + The matrix to factor. + If is null. + If is not a square matrix. + + + + Solves a system of linear equations, AX = B, with A LU factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A LU factorized. + + The right hand side vector, b. + The left hand side , x. + + + + Returns the inverse of this matrix. The inverse is calculated using LU decomposition. + + The inverse of this matrix. + + + + A class which encapsulates the functionality of the QR decomposition. + Any real square matrix A may be decomposed as A = QR where Q is an orthogonal matrix + (its columns are orthogonal unit vectors meaning QTQ = I) and R is an upper triangular matrix + (also called right triangular matrix). + + + The computation of the QR decomposition is done at construction time by Householder transformation. + + + + + Initializes a new instance of the class. This object will compute the + QR factorization when the constructor is called and cache it's factorization. + + The matrix to factor. + The QR factorization method to use. + If is null. + + + + Generate column from initial matrix to work array + + Initial matrix + The first row + Column index + Generated vector + + + + Perform calculation of Q or R + + Work array + Q or R matrices + The first row + The last row + The first column + The last column + Number of available CPUs + + + + Solves a system of linear equations, AX = B, with A QR factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A QR factorized. + + The right hand side vector, b. + The left hand side , x. + + + + A class which encapsulates the functionality of the singular value decomposition (SVD) for . + Suppose M is an m-by-n matrix whose entries are real numbers. + Then there exists a factorization of the form M = UΣVT where: + - U is an m-by-m unitary matrix; + - Σ is m-by-n diagonal matrix with nonnegative real numbers on the diagonal; + - VT denotes transpose of V, an n-by-n unitary matrix; + Such a factorization is called a singular-value decomposition of M. A common convention is to order the diagonal + entries Σ(i,i) in descending order. In this case, the diagonal matrix Σ is uniquely determined + by M (though the matrices U and V are not). The diagonal entries of Σ are known as the singular values of M. + + + The computation of the singular value decomposition is done at construction time. + + + + + Initializes a new instance of the class. This object will compute the + the singular value decomposition when the constructor is called and cache it's decomposition. + + The matrix to factor. + Compute the singular U and VT vectors or not. + If is null. + + + + + Calculates absolute value of multiplied on signum function of + + Complex value z1 + Complex value z2 + Result multiplication of signum function and absolute value + + + + Interchanges two vectors and + + Source matrix + The number of rows in + Column A index to swap + Column B index to swap + + + + Scale column by starting from row + + Source matrix + The number of rows in + Column to scale + Row to scale from + Scale value + + + + Scale vector by starting from index + + Source vector + Row to scale from + Scale value + + + + Given the Cartesian coordinates (da, db) of a point p, these function return the parameters da, db, c, and s + associated with the Givens rotation that zeros the y-coordinate of the point. + + Provides the x-coordinate of the point p. On exit contains the parameter r associated with the Givens rotation + Provides the y-coordinate of the point p. On exit contains the parameter z associated with the Givens rotation + Contains the parameter c associated with the Givens rotation + Contains the parameter s associated with the Givens rotation + This is equivalent to the DROTG LAPACK routine. + + + + Calculate Norm 2 of the column in matrix starting from row + + Source matrix + The number of rows in + Column index + Start row index + Norm2 (Euclidean norm) of the column + + + + Calculate Norm 2 of the vector starting from index + + Source vector + Start index + Norm2 (Euclidean norm) of the vector + + + + Calculate dot product of and conjugating the first vector. + + Source matrix + The number of rows in + Index of column A + Index of column B + Starting row index + Dot product value + + + + Performs rotation of points in the plane. Given two vectors x and y , + each vector element of these vectors is replaced as follows: x(i) = c*x(i) + s*y(i); y(i) = c*y(i) - s*x(i) + + Source matrix + The number of rows in + Index of column A + Index of column B + scalar cos value + scalar sin value + + + + Solves a system of linear equations, AX = B, with A SVD factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A SVD factorized. + + The right hand side vector, b. + The left hand side , x. + + + + Complex version of the class. + + + + + Initializes a new instance of the Matrix class. + + + + + Set all values whose absolute value is smaller than the threshold to zero. + + + + + Returns the conjugate transpose of this matrix. + + The conjugate transpose of this matrix. + + + + Puts the conjugate transpose of this matrix into the result matrix. + + + + + Complex conjugates each element of this matrix and place the results into the result matrix. + + The result of the conjugation. + + + + Negate each element of this matrix and place the results into the result matrix. + + The result of the negation. + + + + Add a scalar to each element of the matrix and stores the result in the result vector. + + The scalar to add. + The matrix to store the result of the addition. + + + + Adds another matrix to this matrix. + + The matrix to add to this matrix. + The matrix to store the result of the addition. + If the other matrix is . + If the two matrices don't have the same dimensions. + + + + Subtracts a scalar from each element of the vector and stores the result in the result vector. + + The scalar to subtract. + The matrix to store the result of the subtraction. + + + + Subtracts another matrix from this matrix. + + The matrix to subtract to this matrix. + The matrix to store the result of subtraction. + If the other matrix is . + If the two matrices don't have the same dimensions. + + + + Multiplies each element of the matrix by a scalar and places results into the result matrix. + + The scalar to multiply the matrix with. + The matrix to store the result of the multiplication. + + + + Multiplies this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + + + + Multiplies this matrix with another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Divides each element of the matrix by a scalar and places results into the result matrix. + + The scalar to divide the matrix with. + The matrix to store the result of the division. + + + + Divides a scalar by each element of the matrix and stores the result in the result matrix. + + The scalar to divide by each element of the matrix. + The matrix to store the result of the division. + + + + Multiplies this matrix with transpose of another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies this matrix with the conjugate transpose of another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies the transpose of this matrix with another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies the transpose of this matrix with another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies the transpose of this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + + + + Multiplies the conjugate transpose of this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + + + + Pointwise multiplies this matrix with another matrix and stores the result into the result matrix. + + The matrix to pointwise multiply with this one. + The matrix to store the result of the pointwise multiplication. + + + + Pointwise divide this matrix by another matrix and stores the result into the result matrix. + + The matrix to pointwise divide this one by. + The matrix to store the result of the pointwise division. + + + + Pointwise raise this matrix to an exponent and store the result into the result matrix. + + The exponent to raise this matrix values to. + The matrix to store the result of the pointwise power. + + + + Pointwise raise this matrix to an exponent and store the result into the result matrix. + + The exponent to raise this matrix values to. + The vector to store the result of the pointwise power. + + + + Pointwise canonical modulus, where the result has the sign of the divisor, + of this matrix with another matrix and stores the result into the result matrix. + + The pointwise denominator matrix to use + The result of the modulus. + + + + Pointwise remainder (% operator), where the result has the sign of the dividend, + of this matrix with another matrix and stores the result into the result matrix. + + The pointwise denominator matrix to use + The result of the modulus. + + + + Computes the canonical modulus, where the result has the sign of the divisor, + for the given divisor each element of the matrix. + + The scalar denominator to use. + Matrix to store the results in. + + + + Computes the canonical modulus, where the result has the sign of the divisor, + for the given dividend for each element of the matrix. + + The scalar numerator to use. + A vector to store the results in. + + + + Computes the remainder (% operator), where the result has the sign of the dividend, + for the given divisor each element of the matrix. + + The scalar denominator to use. + Matrix to store the results in. + + + + Computes the remainder (% operator), where the result has the sign of the dividend, + for the given dividend for each element of the matrix. + + The scalar numerator to use. + A vector to store the results in. + + + + Pointwise applies the exponential function to each value and stores the result into the result matrix. + + The matrix to store the result. + + + + Pointwise applies the natural logarithm function to each value and stores the result into the result matrix. + + The matrix to store the result. + + + + Computes the Moore-Penrose Pseudo-Inverse of this matrix. + + + + + Computes the trace of this matrix. + + The trace of this matrix + If the matrix is not square + + + Calculates the induced L1 norm of this matrix. + The maximum absolute column sum of the matrix. + + + Calculates the induced infinity norm of this matrix. + The maximum absolute row sum of the matrix. + + + Calculates the entry-wise Frobenius norm of this matrix. + The square root of the sum of the squared values. + + + + Calculates the p-norms of all row vectors. + Typical values for p are 1.0 (L1, Manhattan norm), 2.0 (L2, Euclidean norm) and positive infinity (infinity norm) + + + + + Calculates the p-norms of all column vectors. + Typical values for p are 1.0 (L1, Manhattan norm), 2.0 (L2, Euclidean norm) and positive infinity (infinity norm) + + + + + Normalizes all row vectors to a unit p-norm. + Typical values for p are 1.0 (L1, Manhattan norm), 2.0 (L2, Euclidean norm) and positive infinity (infinity norm) + + + + + Normalizes all column vectors to a unit p-norm. + Typical values for p are 1.0 (L1, Manhattan norm), 2.0 (L2, Euclidean norm) and positive infinity (infinity norm) + + + + + Calculates the value sum of each row vector. + + + + + Calculates the absolute value sum of each row vector. + + + + + Calculates the value sum of each column vector. + + + + + Calculates the absolute value sum of each column vector. + + + + + Evaluates whether this matrix is Hermitian (conjugate symmetric). + + + + + A Bi-Conjugate Gradient stabilized iterative matrix solver. + + + + The Bi-Conjugate Gradient Stabilized (BiCGStab) solver is an 'improvement' + of the standard Conjugate Gradient (CG) solver. Unlike the CG solver the + BiCGStab can be used on non-symmetric matrices.
    + Note that much of the success of the solver depends on the selection of the + proper preconditioner. +     + + The Bi-CGSTAB algorithm was taken from:
    + Templates for the solution of linear systems: Building blocks + for iterative methods +
    + Richard Barrett, Michael Berry, Tony F. Chan, James Demmel, + June M. Donato, Jack Dongarra, Victor Eijkhout, Roldan Pozo, + Charles Romine and Henk van der Vorst +
    + Url: http://www.netlib.org/templates/Templates.html +
    + Algorithm is described in Chapter 2, section 2.3.8, page 27 +     + + The example code below provides an indication of the possible use of the + solver. + +     +     + + + Calculates the true residual of the matrix equation Ax = b according to: residual = b - Ax + + Instance of the A. + Residual values in . + Instance of the x. + Instance of the b. + + + + Solves the matrix equation Ax = b, where A is the coefficient matrix, b is the + solution vector and x is the unknown vector. + + The coefficient , A. + The solution , b. + The result , x. + The iterator to use to control when to stop iterating. + The preconditioner to use for approximations. + + + + A composite matrix solver. The actual solver is made by a sequence of + matrix solvers. + + + + Solver based on:
    + Faster PDE-based simulations using robust composite linear solvers
    + S. Bhowmicka, P. Raghavan a,*, L. McInnes b, B. Norris
    + Future Generation Computer Systems, Vol 20, 2004, pp 373�387
    +     + + Note that if an iterator is passed to this solver it will be used for all the sub-solvers. + +     +     + + + The collection of solvers that will be used + + + + + Solves the matrix equation Ax = b, where A is the coefficient matrix, b is the + solution vector and x is the unknown vector. + + The coefficient matrix, A. + The solution vector, b + The result vector, x + The iterator to use to control when to stop iterating. + The preconditioner to use for approximations. + + + + A diagonal preconditioner. The preconditioner uses the inverse + of the matrix diagonal as preconditioning values. + + + + + The inverse of the matrix diagonal. + + + + + Returns the decomposed matrix diagonal. + + The matrix diagonal. + + + + Initializes the preconditioner and loads the internal data structures. + + + The upon which this preconditioner is based. + If is . + If is not a square matrix. + + + + Approximates the solution to the matrix equation Ax = b. + + The right hand side vector. + The left hand side vector. Also known as the result vector. + + + + A Generalized Product Bi-Conjugate Gradient iterative matrix solver. + + + + The Generalized Product Bi-Conjugate Gradient (GPBiCG) solver is an + alternative version of the Bi-Conjugate Gradient stabilized (CG) solver. + Unlike the CG solver the GPBiCG solver can be used on + non-symmetric matrices.
    + Note that much of the success of the solver depends on the selection of the + proper preconditioner. +     + + The GPBiCG algorithm was taken from:
    + GPBiCG(m,l): A hybrid of BiCGSTAB and GPBiCG methods with + efficiency and robustness +
    + S. Fujino +
    + Applied Numerical Mathematics, Volume 41, 2002, pp 107 - 117 +
    +     + + The example code below provides an indication of the possible use of the + solver. + +     +     + + + Indicates the number of BiCGStab steps should be taken + before switching. + + + + + Indicates the number of GPBiCG steps should be taken + before switching. + + + + + Gets or sets the number of steps taken with the BiCgStab algorithm + before switching over to the GPBiCG algorithm. + + + + + Gets or sets the number of steps taken with the GPBiCG algorithm + before switching over to the BiCgStab algorithm. + + + + + Calculates the true residual of the matrix equation Ax = b according to: residual = b - Ax + + Instance of the A. + Residual values in . + Instance of the x. + Instance of the b. + + + + Decide if to do steps with BiCgStab + + Number of iteration + true if yes, otherwise false + + + + Solves the matrix equation Ax = b, where A is the coefficient matrix, b is the + solution vector and x is the unknown vector. + + The coefficient matrix, A. + The solution vector, b + The result vector, x + The iterator to use to control when to stop iterating. + The preconditioner to use for approximations. + + + + An incomplete, level 0, LU factorization preconditioner. + + + The ILU(0) algorithm was taken from:
    + Iterative methods for sparse linear systems
    + Yousef Saad
    + Algorithm is described in Chapter 10, section 10.3.2, page 275
    +     +     + + + The matrix holding the lower (L) and upper (U) matrices. The + decomposition matrices are combined to reduce storage. + + + + + Returns the upper triagonal matrix that was created during the LU decomposition. + + A new matrix containing the upper triagonal elements. + + + + Returns the lower triagonal matrix that was created during the LU decomposition. + + A new matrix containing the lower triagonal elements. + + + + Initializes the preconditioner and loads the internal data structures. + + The matrix upon which the preconditioner is based. + If is . + If is not a square matrix. + + + + Approximates the solution to the matrix equation Ax = b. + + The right hand side vector. + The left hand side vector. Also known as the result vector. + + + + This class performs an Incomplete LU factorization with drop tolerance + and partial pivoting. The drop tolerance indicates which additional entries + will be dropped from the factorized LU matrices. + + + The ILUTP-Mem algorithm was taken from:
    + ILUTP_Mem: a Space-Efficient Incomplete LU Preconditioner +
    + Tzu-Yi Chen, Department of Mathematics and Computer Science,
    + Pomona College, Claremont CA 91711, USA
    + Published in:
    + Lecture Notes in Computer Science
    + Volume 3046 / 2004
    + pp. 20 - 28
    + Algorithm is described in Section 2, page 22 +     +     + + + The default fill level. + + + + + The default drop tolerance. + + + + + The decomposed upper triangular matrix. + + + + + The decomposed lower triangular matrix. + + + + + The array containing the pivot values. + + + + + The fill level. + + + + + The drop tolerance. + + + + + The pivot tolerance. + + + + + Initializes a new instance of the class with the default settings. + + + + + Initializes a new instance of the class with the specified settings. + + + The amount of fill that is allowed in the matrix. The value is a fraction of + the number of non-zero entries in the original matrix. Values should be positive. + + + The absolute drop tolerance which indicates below what absolute value an entry + will be dropped from the matrix. A drop tolerance of 0.0 means that no values + will be dropped. Values should always be positive. + + + The pivot tolerance which indicates at what level pivoting will take place. A + value of 0.0 means that no pivoting will take place. + + + + + Gets or sets the amount of fill that is allowed in the matrix. The + value is a fraction of the number of non-zero entries in the original + matrix. The standard value is 200. + + + + Values should always be positive and can be higher than 1.0. A value lower + than 1.0 means that the eventual preconditioner matrix will have fewer + non-zero entries as the original matrix. A value higher than 1.0 means that + the eventual preconditioner can have more non-zero values than the original + matrix. + + + Note that any changes to the FillLevel after creating the preconditioner + will invalidate the created preconditioner and will require a re-initialization of + the preconditioner. + + + Thrown if a negative value is provided. + + + + Gets or sets the absolute drop tolerance which indicates below what absolute value + an entry will be dropped from the matrix. The standard value is 0.0001. + + + + The values should always be positive and can be larger than 1.0. A low value will + keep more small numbers in the preconditioner matrix. A high value will remove + more small numbers from the preconditioner matrix. + + + Note that any changes to the DropTolerance after creating the preconditioner + will invalidate the created preconditioner and will require a re-initialization of + the preconditioner. + + + Thrown if a negative value is provided. + + + + Gets or sets the pivot tolerance which indicates at what level pivoting will + take place. The standard value is 0.0 which means pivoting will never take place. + + + + The pivot tolerance is used to calculate if pivoting is necessary. Pivoting + will take place if any of the values in a row is bigger than the + diagonal value of that row divided by the pivot tolerance, i.e. pivoting + will take place if row(i,j) > row(i,i) / PivotTolerance for + any j that is not equal to i. + + + Note that any changes to the PivotTolerance after creating the preconditioner + will invalidate the created preconditioner and will require a re-initialization of + the preconditioner. + + + Thrown if a negative value is provided. + + + + Returns the upper triagonal matrix that was created during the LU decomposition. + + + This method is used for debugging purposes only and should normally not be used. + + A new matrix containing the upper triagonal elements. + + + + Returns the lower triagonal matrix that was created during the LU decomposition. + + + This method is used for debugging purposes only and should normally not be used. + + A new matrix containing the lower triagonal elements. + + + + Returns the pivot array. This array is not needed for normal use because + the preconditioner will return the solution vector values in the proper order. + + + This method is used for debugging purposes only and should normally not be used. + + The pivot array. + + + + Initializes the preconditioner and loads the internal data structures. + + + The upon which this preconditioner is based. Note that the + method takes a general matrix type. However internally the data is stored + as a sparse matrix. Therefore it is not recommended to pass a dense matrix. + + If is . + If is not a square matrix. + + + + Pivot elements in the according to internal pivot array + + Row to pivot in + + + + Was pivoting already performed + + Pivots already done + Current item to pivot + true if performed, otherwise false + + + + Swap columns in the + + Source . + First column index to swap + Second column index to swap + + + + Sort vector descending, not changing vector but placing sorted indices to + + Start sort form + Sort till upper bound + Array with sorted vector indices + Source + + + + Approximates the solution to the matrix equation Ax = b. + + The right hand side vector. + The left hand side vector. Also known as the result vector. + + + + Pivot elements in according to internal pivot array + + Source . + Result after pivoting. + + + + An element sort algorithm for the class. + + + This sort algorithm is used to sort the columns in a sparse matrix based on + the value of the element on the diagonal of the matrix. + + + + + Sorts the elements of the vector in decreasing + fashion. The vector itself is not affected. + + The starting index. + The stopping index. + An array that will contain the sorted indices once the algorithm finishes. + The that contains the values that need to be sorted. + + + + Sorts the elements of the vector in decreasing + fashion using heap sort algorithm. The vector itself is not affected. + + The starting index. + The stopping index. + An array that will contain the sorted indices once the algorithm finishes. + The that contains the values that need to be sorted. + + + + Build heap for double indices + + Root position + Length of + Indices of + Target + + + + Sift double indices + + Indices of + Target + Root position + Length of + + + + Sorts the given integers in a decreasing fashion. + + The values. + + + + Sort the given integers in a decreasing fashion using heapsort algorithm + + Array of values to sort + Length of + + + + Build heap + + Target values array + Root position + Length of + + + + Sift values + + Target value array + Root position + Length of + + + + Exchange values in array + + Target values array + First value to exchange + Second value to exchange + + + + A simple milu(0) preconditioner. + + + Original Fortran code by Yousef Saad (07 January 2004) + + + + Use modified or standard ILU(0) + + + + Gets or sets a value indicating whether to use modified or standard ILU(0). + + + + + Gets a value indicating whether the preconditioner is initialized. + + + + + Initializes the preconditioner and loads the internal data structures. + + The matrix upon which the preconditioner is based. + If is . + If is not a square or is not an + instance of SparseCompressedRowMatrixStorage. + + + + Approximates the solution to the matrix equation Ax = b. + + The right hand side vector b. + The left hand side vector x. + + + + MILU0 is a simple milu(0) preconditioner. + + Order of the matrix. + Matrix values in CSR format (input). + Column indices (input). + Row pointers (input). + Matrix values in MSR format (output). + Row pointers and column indices (output). + Pointer to diagonal elements (output). + True if the modified/MILU algorithm should be used (recommended) + Returns 0 on success or k > 0 if a zero pivot was encountered at step k. + + + + A Multiple-Lanczos Bi-Conjugate Gradient stabilized iterative matrix solver. + + + + The Multiple-Lanczos Bi-Conjugate Gradient stabilized (ML(k)-BiCGStab) solver is an 'improvement' + of the standard BiCgStab solver. + + + The algorithm was taken from:
    + ML(k)BiCGSTAB: A BiCGSTAB variant based on multiple Lanczos starting vectors +
    + Man-Chung Yeung and Tony F. Chan +
    + SIAM Journal of Scientific Computing +
    + Volume 21, Number 4, pp. 1263 - 1290 +     + + The example code below provides an indication of the possible use of the + solver. + +     +     + + + The default number of starting vectors. + + + + + The collection of starting vectors which are used as the basis for the Krylov sub-space. + + + + + The number of starting vectors used by the algorithm + + + + + Gets or sets the number of starting vectors. + + + Must be larger than 1 and smaller than the number of variables in the matrix that + for which this solver will be used. + + + + + Resets the number of starting vectors to the default value. + + + + + Gets or sets a series of orthonormal vectors which will be used as basis for the + Krylov sub-space. + + + + + Gets the number of starting vectors to create + + Maximum number + Number of variables + Number of starting vectors to create + + + + Returns an array of starting vectors. + + The maximum number of starting vectors that should be created. + The number of variables. + + An array with starting vectors. The array will never be larger than the + but it may be smaller if + the is smaller than + the . + + + + + Create random vectors array + + Number of vectors + Size of each vector + Array of random vectors + + + + Calculates the true residual of the matrix equation Ax = b according to: residual = b - Ax + + Source A. + Residual data. + x data. + b data. + + + + Solves the matrix equation Ax = b, where A is the coefficient matrix, b is the + solution vector and x is the unknown vector. + + The coefficient matrix, A. + The solution vector, b + The result vector, x + The iterator to use to control when to stop iterating. + The preconditioner to use for approximations. + + + + A Transpose Free Quasi-Minimal Residual (TFQMR) iterative matrix solver. + + + + The TFQMR algorithm was taken from:
    + Iterative methods for sparse linear systems. +
    + Yousef Saad +
    + Algorithm is described in Chapter 7, section 7.4.3, page 219 +     + + The example code below provides an indication of the possible use of the + solver. + +     +     + + + Calculates the true residual of the matrix equation Ax = b according to: residual = b - Ax + + Instance of the A. + Residual values in . + Instance of the x. + Instance of the b. + + + + Is even? + + Number to check + true if even, otherwise false + + + + Solves the matrix equation Ax = b, where A is the coefficient matrix, b is the + solution vector and x is the unknown vector. + + The coefficient matrix, A. + The solution vector, b + The result vector, x + The iterator to use to control when to stop iterating. + The preconditioner to use for approximations. + + + + A Matrix with sparse storage, intended for very large matrices where most of the cells are zero. + The underlying storage scheme is 3-array compressed-sparse-row (CSR) Format. + Wikipedia - CSR. + + + + + Gets the number of non zero elements in the matrix. + + The number of non zero elements. + + + + Create a new sparse matrix straight from an initialized matrix storage instance. + The storage is used directly without copying. + Intended for advanced scenarios where you're working directly with + storage for performance or interop reasons. + + + + + Create a new square sparse matrix with the given number of rows and columns. + All cells of the matrix will be initialized to zero. + + If the order is less than one. + + + + Create a new sparse matrix with the given number of rows and columns. + All cells of the matrix will be initialized to zero. + + If the row or column count is less than one. + + + + Create a new sparse matrix as a copy of the given other matrix. + This new matrix will be independent from the other matrix. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given two-dimensional array. + This new matrix will be independent from the provided array. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given enumerable. + The enumerable is assumed to be in row-major order (row by row). + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the vector. + + + + + + Create a new sparse matrix with the given number of rows and columns as a copy of the given array. + The array is assumed to be in column-major order (column by column). + This new matrix will be independent from the provided array. + A new memory block will be allocated for storing the matrix. + + + + + + Create a new sparse matrix as a copy of the given enumerable of enumerable columns. + Each enumerable in the master enumerable specifies a column. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given enumerable of enumerable columns. + Each enumerable in the master enumerable specifies a column. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given column arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given column arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given column vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given column vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given enumerable of enumerable rows. + Each enumerable in the master enumerable specifies a row. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given enumerable of enumerable rows. + Each enumerable in the master enumerable specifies a row. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given row arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given row arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given row vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given row vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix with the diagonal as a copy of the given vector. + This new matrix will be independent from the vector. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix with the diagonal as a copy of the given vector. + This new matrix will be independent from the vector. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix with the diagonal as a copy of the given array. + This new matrix will be independent from the array. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix with the diagonal as a copy of the given array. + This new matrix will be independent from the array. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix and initialize each value to the same provided value. + + + + + Create a new sparse matrix and initialize each value using the provided init function. + + + + + Create a new diagonal sparse matrix and initialize each diagonal value to the same provided value. + + + + + Create a new diagonal sparse matrix and initialize each diagonal value using the provided init function. + + + + + Create a new square sparse identity matrix where each diagonal value is set to One. + + + + + Returns a new matrix containing the lower triangle of this matrix. + + The lower triangle of this matrix. + + + + Puts the lower triangle of this matrix into the result matrix. + + Where to store the lower triangle. + If is . + If the result matrix's dimensions are not the same as this matrix. + + + + Puts the lower triangle of this matrix into the result matrix. + + Where to store the lower triangle. + + + + Returns a new matrix containing the upper triangle of this matrix. + + The upper triangle of this matrix. + + + + Puts the upper triangle of this matrix into the result matrix. + + Where to store the lower triangle. + If is . + If the result matrix's dimensions are not the same as this matrix. + + + + Puts the upper triangle of this matrix into the result matrix. + + Where to store the lower triangle. + + + + Returns a new matrix containing the lower triangle of this matrix. The new matrix + does not contain the diagonal elements of this matrix. + + The lower triangle of this matrix. + + + + Puts the strictly lower triangle of this matrix into the result matrix. + + Where to store the lower triangle. + If is . + If the result matrix's dimensions are not the same as this matrix. + + + + Puts the strictly lower triangle of this matrix into the result matrix. + + Where to store the lower triangle. + + + + Returns a new matrix containing the upper triangle of this matrix. The new matrix + does not contain the diagonal elements of this matrix. + + The upper triangle of this matrix. + + + + Puts the strictly upper triangle of this matrix into the result matrix. + + Where to store the lower triangle. + If is . + If the result matrix's dimensions are not the same as this matrix. + + + + Puts the strictly upper triangle of this matrix into the result matrix. + + Where to store the lower triangle. + + + + Negate each element of this matrix and place the results into the result matrix. + + The result of the negation. + + + Calculates the induced infinity norm of this matrix. + The maximum absolute row sum of the matrix. + + + Calculates the entry-wise Frobenius norm of this matrix. + The square root of the sum of the squared values. + + + + Adds another matrix to this matrix. + + The matrix to add to this matrix. + The matrix to store the result of the addition. + If the other matrix is . + If the two matrices don't have the same dimensions. + + + + Subtracts another matrix from this matrix. + + The matrix to subtract to this matrix. + The matrix to store the result of subtraction. + If the other matrix is . + If the two matrices don't have the same dimensions. + + + + Multiplies each element of the matrix by a scalar and places results into the result matrix. + + The scalar to multiply the matrix with. + The matrix to store the result of the multiplication. + + + + Multiplies this matrix with another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + + + + Multiplies this matrix with transpose of another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies the transpose of this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + + + + Pointwise multiplies this matrix with another matrix and stores the result into the result matrix. + + The matrix to pointwise multiply with this one. + The matrix to store the result of the pointwise multiplication. + + + + Pointwise divide this matrix by another matrix and stores the result into the result matrix. + + The matrix to pointwise divide this one by. + The matrix to store the result of the pointwise division. + + + + Evaluates whether this matrix is symmetric. + + + + + Evaluates whether this matrix is Hermitian (conjugate symmetric). + + + + + Adds two matrices together and returns the results. + + This operator will allocate new memory for the result. It will + choose the representation of either or depending on which + is denser. + The left matrix to add. + The right matrix to add. + The result of the addition. + If and don't have the same dimensions. + If or is . + + + + Returns a Matrix containing the same values of . + + The matrix to get the values from. + A matrix containing a the same values as . + If is . + + + + Subtracts two matrices together and returns the results. + + This operator will allocate new memory for the result. It will + choose the representation of either or depending on which + is denser. + The left matrix to subtract. + The right matrix to subtract. + The result of the addition. + If and don't have the same dimensions. + If or is . + + + + Negates each element of the matrix. + + The matrix to negate. + A matrix containing the negated values. + If is . + + + + Multiplies a Matrix by a constant and returns the result. + + The matrix to multiply. + The constant to multiply the matrix by. + The result of the multiplication. + If is . + + + + Multiplies a Matrix by a constant and returns the result. + + The matrix to multiply. + The constant to multiply the matrix by. + The result of the multiplication. + If is . + + + + Multiplies two matrices. + + This operator will allocate new memory for the result. It will + choose the representation of either or depending on which + is denser. + The left matrix to multiply. + The right matrix to multiply. + The result of multiplication. + If or is . + If the dimensions of or don't conform. + + + + Multiplies a Matrix and a Vector. + + The matrix to multiply. + The vector to multiply. + The result of multiplication. + If or is . + + + + Multiplies a Vector and a Matrix. + + The vector to multiply. + The matrix to multiply. + The result of multiplication. + If or is . + + + + Multiplies a Matrix by a constant and returns the result. + + The matrix to multiply. + The constant to multiply the matrix by. + The result of the multiplication. + If is . + + + + A vector with sparse storage, intended for very large vectors where most of the cells are zero. + + The sparse vector is not thread safe. + + + + Gets the number of non zero elements in the vector. + + The number of non zero elements. + + + + Create a new sparse vector straight from an initialized vector storage instance. + The storage is used directly without copying. + Intended for advanced scenarios where you're working directly with + storage for performance or interop reasons. + + + + + Create a new sparse vector with the given length. + All cells of the vector will be initialized to zero. + + If length is less than one. + + + + Create a new sparse vector as a copy of the given other vector. + This new vector will be independent from the other vector. + A new memory block will be allocated for storing the vector. + + + + + Create a new sparse vector as a copy of the given enumerable. + This new vector will be independent from the enumerable. + A new memory block will be allocated for storing the vector. + + + + + Create a new sparse vector as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new vector will be independent from the enumerable. + A new memory block will be allocated for storing the vector. + + + + + Create a new sparse vector as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new vector will be independent from the enumerable. + A new memory block will be allocated for storing the vector. + + + + + Create a new sparse vector and initialize each value using the provided value. + + + + + Create a new sparse vector and initialize each value using the provided init function. + + + + + Adds a scalar to each element of the vector and stores the result in the result vector. + Warning, the new 'sparse vector' with a non-zero scalar added to it will be a 100% filled + sparse vector and very inefficient. Would be better to work with a dense vector instead. + + + The scalar to add. + + + The vector to store the result of the addition. + + + + + Adds another vector to this vector and stores the result into the result vector. + + + The vector to add to this one. + + + The vector to store the result of the addition. + + + + + Subtracts a scalar from each element of the vector and stores the result in the result vector. + + + The scalar to subtract. + + + The vector to store the result of the subtraction. + + + + + Subtracts another vector to this vector and stores the result into the result vector. + + + The vector to subtract from this one. + + + The vector to store the result of the subtraction. + + + + + Negates vector and saves result to + + Target vector + + + + Conjugates vector and save result to + + Target vector + + + + Multiplies a scalar to each element of the vector and stores the result in the result vector. + + + The scalar to multiply. + + + The vector to store the result of the multiplication. + + + + + Computes the dot product between this vector and another vector. + + The other vector. + The sum of a[i]*b[i] for all i. + + + + Computes the dot product between the conjugate of this vector and another vector. + + The other vector. + The sum of conj(a[i])*b[i] for all i. + + + + Adds two Vectors together and returns the results. + + One of the vectors to add. + The other vector to add. + The result of the addition. + If and are not the same size. + If or is . + + + + Returns a Vector containing the negated values of . + + The vector to get the values from. + A vector containing the negated values as . + If is . + + + + Subtracts two Vectors and returns the results. + + The vector to subtract from. + The vector to subtract. + The result of the subtraction. + If and are not the same size. + If or is . + + + + Multiplies a vector with a complex. + + The vector to scale. + The complex value. + The result of the multiplication. + If is . + + + + Multiplies a vector with a complex. + + The complex value. + The vector to scale. + The result of the multiplication. + If is . + + + + Computes the dot product between two Vectors. + + The left row vector. + The right column vector. + The dot product between the two vectors. + If and are not the same size. + If or is . + + + + Divides a vector with a complex. + + The vector to divide. + The complex value. + The result of the division. + If is . + + + + Computes the modulus of each element of the vector of the given divisor. + + The vector whose elements we want to compute the modulus of. + The divisor to use, + The result of the calculation + If is . + + + + Returns the index of the absolute minimum element. + + The index of absolute minimum element. + + + + Returns the index of the absolute maximum element. + + The index of absolute maximum element. + + + + Computes the sum of the vector's elements. + + The sum of the vector's elements. + + + + Calculates the L1 norm of the vector, also known as Manhattan norm. + + The sum of the absolute values. + + + + Calculates the infinity norm of the vector. + + The maximum absolute value. + + + + Computes the p-Norm. + + The p value. + Scalar ret = ( ∑|this[i]|^p )^(1/p) + + + + Pointwise multiplies this vector with another vector and stores the result into the result vector. + + The vector to pointwise multiply with this one. + The vector to store the result of the pointwise multiplication. + + + + Creates a double sparse vector based on a string. The string can be in the following formats (without the + quotes): 'n', 'n;n;..', '(n;n;..)', '[n;n;...]', where n is a Complex. + + + A double sparse vector containing the values specified by the given string. + + + the string to parse. + + + An that supplies culture-specific formatting information. + + + + + Converts the string representation of a complex sparse vector to double-precision sparse vector equivalent. + A return value indicates whether the conversion succeeded or failed. + + + A string containing a complex vector to convert. + + + The parsed value. + + + If the conversion succeeds, the result will contain a complex number equivalent to value. + Otherwise the result will be null. + + + + + Converts the string representation of a complex sparse vector to double-precision sparse vector equivalent. + A return value indicates whether the conversion succeeded or failed. + + + A string containing a complex vector to convert. + + + An that supplies culture-specific formatting information about value. + + + The parsed value. + + + If the conversion succeeds, the result will contain a complex number equivalent to value. + Otherwise the result will be null. + + + + + Complex version of the class. + + + + + Initializes a new instance of the Vector class. + + + + + Set all values whose absolute value is smaller than the threshold to zero. + + + + + Conjugates vector and save result to + + Target vector + + + + Negates vector and saves result to + + Target vector + + + + Adds a scalar to each element of the vector and stores the result in the result vector. + + + The scalar to add. + + + The vector to store the result of the addition. + + + + + Adds another vector to this vector and stores the result into the result vector. + + + The vector to add to this one. + + + The vector to store the result of the addition. + + + + + Subtracts a scalar from each element of the vector and stores the result in the result vector. + + + The scalar to subtract. + + + The vector to store the result of the subtraction. + + + + + Subtracts another vector to this vector and stores the result into the result vector. + + + The vector to subtract from this one. + + + The vector to store the result of the subtraction. + + + + + Multiplies a scalar to each element of the vector and stores the result in the result vector. + + + The scalar to multiply. + + + The vector to store the result of the multiplication. + + + + + Divides each element of the vector by a scalar and stores the result in the result vector. + + + The scalar to divide with. + + + The vector to store the result of the division. + + + + + Divides a scalar by each element of the vector and stores the result in the result vector. + + The scalar to divide. + The vector to store the result of the division. + + + + Pointwise multiplies this vector with another vector and stores the result into the result vector. + + The vector to pointwise multiply with this one. + The vector to store the result of the pointwise multiplication. + + + + Pointwise divide this vector with another vector and stores the result into the result vector. + + The vector to pointwise divide this one by. + The vector to store the result of the pointwise division. + + + + Pointwise raise this vector to an exponent and store the result into the result vector. + + The exponent to raise this vector values to. + The vector to store the result of the pointwise power. + + + + Pointwise raise this vector to an exponent vector and store the result into the result vector. + + The exponent vector to raise this vector values to. + The vector to store the result of the pointwise power. + + + + Pointwise canonical modulus, where the result has the sign of the divisor, + of this vector with another vector and stores the result into the result vector. + + The pointwise denominator vector to use. + The result of the modulus. + + + + Pointwise remainder (% operator), where the result has the sign of the dividend, + of this vector with another vector and stores the result into the result vector. + + The pointwise denominator vector to use. + The result of the modulus. + + + + Pointwise applies the exponential function to each value and stores the result into the result vector. + + The vector to store the result. + + + + Pointwise applies the natural logarithm function to each value and stores the result into the result vector. + + The vector to store the result. + + + + Computes the dot product between this vector and another vector. + + The other vector. + The sum of a[i]*b[i] for all i. + + + + Computes the dot product between the conjugate of this vector and another vector. + + The other vector. + The sum of conj(a[i])*b[i] for all i. + + + + Computes the canonical modulus, where the result has the sign of the divisor, + for each element of the vector for the given divisor. + + The scalar denominator to use. + A vector to store the results in. + + + + Computes the canonical modulus, where the result has the sign of the divisor, + for the given dividend for each element of the vector. + + The scalar numerator to use. + A vector to store the results in. + + + + Computes the canonical modulus, where the result has the sign of the divisor, + for each element of the vector for the given divisor. + + The scalar denominator to use. + A vector to store the results in. + + + + Computes the canonical modulus, where the result has the sign of the divisor, + for the given dividend for each element of the vector. + + The scalar numerator to use. + A vector to store the results in. + + + + Returns the value of the absolute minimum element. + + The value of the absolute minimum element. + + + + Returns the index of the absolute minimum element. + + The index of absolute minimum element. + + + + Returns the value of the absolute maximum element. + + The value of the absolute maximum element. + + + + Returns the index of the absolute maximum element. + + The index of absolute maximum element. + + + + Computes the sum of the vector's elements. + + The sum of the vector's elements. + + + + Calculates the L1 norm of the vector, also known as Manhattan norm. + + The sum of the absolute values. + + + + Calculates the L2 norm of the vector, also known as Euclidean norm. + + The square root of the sum of the squared values. + + + + Calculates the infinity norm of the vector. + + The maximum absolute value. + + + + Computes the p-Norm. + + + The p value. + + + Scalar ret = ( ∑|At(i)|^p )^(1/p) + + + + + Returns the index of the maximum element. + + The index of maximum element. + + + + Returns the index of the minimum element. + + The index of minimum element. + + + + Normalizes this vector to a unit vector with respect to the p-norm. + + + The p value. + + + This vector normalized to a unit vector with respect to the p-norm. + + + + + A Matrix class with dense storage. The underlying storage is a one dimensional array in column-major order (column by column). + + + + + Number of rows. + + Using this instead of the RowCount property to speed up calculating + a matrix index in the data array. + + + + Number of columns. + + Using this instead of the ColumnCount property to speed up calculating + a matrix index in the data array. + + + + Gets the matrix's data. + + The matrix's data. + + + + Create a new dense matrix straight from an initialized matrix storage instance. + The storage is used directly without copying. + Intended for advanced scenarios where you're working directly with + storage for performance or interop reasons. + + + + + Create a new square dense matrix with the given number of rows and columns. + All cells of the matrix will be initialized to zero. + + If the order is less than one. + + + + Create a new dense matrix with the given number of rows and columns. + All cells of the matrix will be initialized to zero. + + If the row or column count is less than one. + + + + Create a new dense matrix with the given number of rows and columns directly binding to a raw array. + The array is assumed to be in column-major order (column by column) and is used directly without copying. + Very efficient, but changes to the array and the matrix will affect each other. + + + + + + Create a new dense matrix as a copy of the given other matrix. + This new matrix will be independent from the other matrix. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given two-dimensional array. + This new matrix will be independent from the provided array. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given enumerable. + The enumerable is assumed to be in column-major order (column by column). + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given enumerable of enumerable columns. + Each enumerable in the master enumerable specifies a column. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given enumerable of enumerable columns. + Each enumerable in the master enumerable specifies a column. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given column arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given column arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given column vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given column vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given enumerable of enumerable rows. + Each enumerable in the master enumerable specifies a row. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given enumerable of enumerable rows. + Each enumerable in the master enumerable specifies a row. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given row arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given row arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given row vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given row vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix with the diagonal as a copy of the given vector. + This new matrix will be independent from the vector. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix with the diagonal as a copy of the given vector. + This new matrix will be independent from the vector. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix with the diagonal as a copy of the given array. + This new matrix will be independent from the array. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix with the diagonal as a copy of the given array. + This new matrix will be independent from the array. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix and initialize each value to the same provided value. + + + + + Create a new dense matrix and initialize each value using the provided init function. + + + + + Create a new diagonal dense matrix and initialize each diagonal value to the same provided value. + + + + + Create a new diagonal dense matrix and initialize each diagonal value using the provided init function. + + + + + Create a new square sparse identity matrix where each diagonal value is set to One. + + + + + Create a new dense matrix with values sampled from the provided random distribution. + + + + + Gets the matrix's data. + + The matrix's data. + + + Calculates the induced L1 norm of this matrix. + The maximum absolute column sum of the matrix. + + + Calculates the induced infinity norm of this matrix. + The maximum absolute row sum of the matrix. + + + Calculates the entry-wise Frobenius norm of this matrix. + The square root of the sum of the squared values. + + + + Negate each element of this matrix and place the results into the result matrix. + + The result of the negation. + + + + Complex conjugates each element of this matrix and place the results into the result matrix. + + The result of the conjugation. + + + + Add a scalar to each element of the matrix and stores the result in the result vector. + + The scalar to add. + The matrix to store the result of the addition. + + + + Adds another matrix to this matrix. + + The matrix to add to this matrix. + The matrix to store the result of add + If the other matrix is . + If the two matrices don't have the same dimensions. + + + + Subtracts a scalar from each element of the matrix and stores the result in the result vector. + + The scalar to subtract. + The matrix to store the result of the subtraction. + + + + Subtracts another matrix from this matrix. + + The matrix to subtract. + The matrix to store the result of the subtraction. + + + + Multiplies each element of the matrix by a scalar and places results into the result matrix. + + The scalar to multiply the matrix with. + The matrix to store the result of the multiplication. + + + + Multiplies this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + + + + Multiplies this matrix with another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies this matrix with transpose of another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies this matrix with the conjugate transpose of another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies the transpose of this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + + + + Multiplies the conjugate transpose of this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + + + + Multiplies the transpose of this matrix with another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies the transpose of this matrix with another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Divides each element of the matrix by a scalar and places results into the result matrix. + + The scalar to divide the matrix with. + The matrix to store the result of the division. + + + + Pointwise multiplies this matrix with another matrix and stores the result into the result matrix. + + The matrix to pointwise multiply with this one. + The matrix to store the result of the pointwise multiplication. + + + + Pointwise divide this matrix by another matrix and stores the result into the result matrix. + + The matrix to pointwise divide this one by. + The matrix to store the result of the pointwise division. + + + + Pointwise raise this matrix to an exponent and store the result into the result matrix. + + The exponent to raise this matrix values to. + The vector to store the result of the pointwise power. + + + + Computes the trace of this matrix. + + The trace of this matrix + If the matrix is not square + + + + Adds two matrices together and returns the results. + + This operator will allocate new memory for the result. It will + choose the representation of either or depending on which + is denser. + The left matrix to add. + The right matrix to add. + The result of the addition. + If and don't have the same dimensions. + If or is . + + + + Returns a Matrix containing the same values of . + + The matrix to get the values from. + A matrix containing a the same values as . + If is . + + + + Subtracts two matrices together and returns the results. + + This operator will allocate new memory for the result. It will + choose the representation of either or depending on which + is denser. + The left matrix to subtract. + The right matrix to subtract. + The result of the addition. + If and don't have the same dimensions. + If or is . + + + + Negates each element of the matrix. + + The matrix to negate. + A matrix containing the negated values. + If is . + + + + Multiplies a Matrix by a constant and returns the result. + + The matrix to multiply. + The constant to multiply the matrix by. + The result of the multiplication. + If is . + + + + Multiplies a Matrix by a constant and returns the result. + + The matrix to multiply. + The constant to multiply the matrix by. + The result of the multiplication. + If is . + + + + Multiplies two matrices. + + This operator will allocate new memory for the result. It will + choose the representation of either or depending on which + is denser. + The left matrix to multiply. + The right matrix to multiply. + The result of multiplication. + If or is . + If the dimensions of or don't conform. + + + + Multiplies a Matrix and a Vector. + + The matrix to multiply. + The vector to multiply. + The result of multiplication. + If or is . + + + + Multiplies a Vector and a Matrix. + + The vector to multiply. + The matrix to multiply. + The result of multiplication. + If or is . + + + + Multiplies a Matrix by a constant and returns the result. + + The matrix to multiply. + The constant to multiply the matrix by. + The result of the multiplication. + If is . + + + + Evaluates whether this matrix is symmetric. + + + + + Evaluates whether this matrix is Hermitian (conjugate symmetric). + + + + + A vector using dense storage. + + + + + Number of elements + + + + + Gets the vector's data. + + + + + Create a new dense vector straight from an initialized vector storage instance. + The storage is used directly without copying. + Intended for advanced scenarios where you're working directly with + storage for performance or interop reasons. + + + + + Create a new dense vector with the given length. + All cells of the vector will be initialized to zero. + + If length is less than one. + + + + Create a new dense vector directly binding to a raw array. + The array is used directly without copying. + Very efficient, but changes to the array and the vector will affect each other. + + + + + Create a new dense vector as a copy of the given other vector. + This new vector will be independent from the other vector. + A new memory block will be allocated for storing the vector. + + + + + Create a new dense vector as a copy of the given array. + This new vector will be independent from the array. + A new memory block will be allocated for storing the vector. + + + + + Create a new dense vector as a copy of the given enumerable. + This new vector will be independent from the enumerable. + A new memory block will be allocated for storing the vector. + + + + + Create a new dense vector as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new vector will be independent from the enumerable. + A new memory block will be allocated for storing the vector. + + + + + Create a new dense vector as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new vector will be independent from the enumerable. + A new memory block will be allocated for storing the vector. + + + + + Create a new dense vector and initialize each value using the provided value. + + + + + Create a new dense vector and initialize each value using the provided init function. + + + + + Create a new dense vector with values sampled from the provided random distribution. + + + + + Gets the vector's data. + + The vector's data. + + + + Returns a reference to the internal data structure. + + The DenseVector whose internal data we are + returning. + + A reference to the internal date of the given vector. + + + + + Returns a vector bound directly to a reference of the provided array. + + The array to bind to the DenseVector object. + + A DenseVector whose values are bound to the given array. + + + + + Adds a scalar to each element of the vector and stores the result in the result vector. + + The scalar to add. + The vector to store the result of the addition. + + + + Adds another vector to this vector and stores the result into the result vector. + + The vector to add to this one. + The vector to store the result of the addition. + + + + Adds two Vectors together and returns the results. + + One of the vectors to add. + The other vector to add. + The result of the addition. + If and are not the same size. + If or is . + + + + Subtracts a scalar from each element of the vector and stores the result in the result vector. + + The scalar to subtract. + The vector to store the result of the subtraction. + + + + Subtracts another vector from this vector and stores the result into the result vector. + + The vector to subtract from this one. + The vector to store the result of the subtraction. + + + + Returns a Vector containing the negated values of . + + The vector to get the values from. + A vector containing the negated values as . + If is . + + + + Subtracts two Vectors and returns the results. + + The vector to subtract from. + The vector to subtract. + The result of the subtraction. + If and are not the same size. + If or is . + + + + Negates vector and saves result to + + Target vector + + + + Conjugates vector and save result to + + Target vector + + + + Multiplies a scalar to each element of the vector and stores the result in the result vector. + + The scalar to multiply. + The vector to store the result of the multiplication. + + + + + Computes the dot product between this vector and another vector. + + The other vector. + The sum of a[i]*b[i] for all i. + + + + Computes the dot product between the conjugate of this vector and another vector. + + The other vector. + The sum of conj(a[i])*b[i] for all i. + + + + Multiplies a vector with a complex. + + The vector to scale. + The Complex32 value. + The result of the multiplication. + If is . + + + + Multiplies a vector with a complex. + + The Complex32 value. + The vector to scale. + The result of the multiplication. + If is . + + + + Computes the dot product between two Vectors. + + The left row vector. + The right column vector. + The dot product between the two vectors. + If and are not the same size. + If or is . + + + + Divides a vector with a complex. + + The vector to divide. + The Complex32 value. + The result of the division. + If is . + + + + Returns the index of the absolute minimum element. + + The index of absolute minimum element. + + + + Returns the index of the absolute maximum element. + + The index of absolute maximum element. + + + + Computes the sum of the vector's elements. + + The sum of the vector's elements. + + + + Calculates the L1 norm of the vector, also known as Manhattan norm. + + The sum of the absolute values. + + + + Calculates the L2 norm of the vector, also known as Euclidean norm. + + The square root of the sum of the squared values. + + + + Calculates the infinity norm of the vector. + + The maximum absolute value. + + + + Computes the p-Norm. + + The p value. + Scalar ret = ( ∑|this[i]|^p )^(1/p) + + + + Pointwise divide this vector with another vector and stores the result into the result vector. + + The vector to pointwise divide this one by. + The vector to store the result of the pointwise division. + + + + Pointwise divide this vector with another vector and stores the result into the result vector. + + The vector to pointwise divide this one by. + The vector to store the result of the pointwise division. + + + + + Pointwise raise this vector to an exponent vector and store the result into the result vector. + + The exponent vector to raise this vector values to. + The vector to store the result of the pointwise power. + + + + Creates a Complex32 dense vector based on a string. The string can be in the following formats (without the + quotes): 'n', 'n;n;..', '(n;n;..)', '[n;n;...]', where n is a double. + + + A Complex32 dense vector containing the values specified by the given string. + + + the string to parse. + + + An that supplies culture-specific formatting information. + + + + + Converts the string representation of a complex dense vector to double-precision dense vector equivalent. + A return value indicates whether the conversion succeeded or failed. + + + A string containing a complex vector to convert. + + + The parsed value. + + + If the conversion succeeds, the result will contain a complex number equivalent to value. + Otherwise the result will be null. + + + + + Converts the string representation of a complex dense vector to double-precision dense vector equivalent. + A return value indicates whether the conversion succeeded or failed. + + + A string containing a complex vector to convert. + + + An that supplies culture-specific formatting information about value. + + + The parsed value. + + + If the conversion succeeds, the result will contain a complex number equivalent to value. + Otherwise the result will be null. + + + + + A matrix type for diagonal matrices. + + + Diagonal matrices can be non-square matrices but the diagonal always starts + at element 0,0. A diagonal matrix will throw an exception if non diagonal + entries are set. The exception to this is when the off diagonal elements are + 0.0 or NaN; these settings will cause no change to the diagonal matrix. + + + + + Gets the matrix's data. + + The matrix's data. + + + + Create a new diagonal matrix straight from an initialized matrix storage instance. + The storage is used directly without copying. + Intended for advanced scenarios where you're working directly with + storage for performance or interop reasons. + + + + + Create a new square diagonal matrix with the given number of rows and columns. + All cells of the matrix will be initialized to zero. + + If the order is less than one. + + + + Create a new diagonal matrix with the given number of rows and columns. + All cells of the matrix will be initialized to zero. + + If the row or column count is less than one. + + + + Create a new diagonal matrix with the given number of rows and columns. + All diagonal cells of the matrix will be initialized to the provided value, all non-diagonal ones to zero. + + If the row or column count is less than one. + + + + Create a new diagonal matrix with the given number of rows and columns directly binding to a raw array. + The array is assumed to contain the diagonal elements only and is used directly without copying. + Very efficient, but changes to the array and the matrix will affect each other. + + + + + Create a new diagonal matrix as a copy of the given other matrix. + This new matrix will be independent from the other matrix. + The matrix to copy from must be diagonal as well. + A new memory block will be allocated for storing the matrix. + + + + + Create a new diagonal matrix as a copy of the given two-dimensional array. + This new matrix will be independent from the provided array. + The array to copy from must be diagonal as well. + A new memory block will be allocated for storing the matrix. + + + + + Create a new diagonal matrix and initialize each diagonal value from the provided indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the matrix. + + + + + Create a new diagonal matrix and initialize each diagonal value from the provided indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the matrix. + + + + + Create a new diagonal matrix and initialize each diagonal value from the provided enumerable. + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the matrix. + + + + + Create a new diagonal matrix and initialize each diagonal value using the provided init function. + + + + + Create a new square sparse identity matrix where each diagonal value is set to One. + + + + + Create a new diagonal matrix with diagonal values sampled from the provided random distribution. + + + + + Negate each element of this matrix and place the results into the result matrix. + + The result of the negation. + + + + Complex conjugates each element of this matrix and place the results into the result matrix. + + The result of the conjugation. + + + + Adds another matrix to this matrix. + + The matrix to add to this matrix. + The matrix to store the result of the addition. + If the two matrices don't have the same dimensions. + + + + Subtracts another matrix from this matrix. + + The matrix to subtract. + The matrix to store the result of the subtraction. + If the two matrices don't have the same dimensions. + + + + Multiplies each element of the matrix by a scalar and places results into the result matrix. + + The scalar to multiply the matrix with. + The matrix to store the result of the multiplication. + + + + Multiplies this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + + + + Multiplies this matrix with another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies this matrix with transpose of another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies this matrix with the conjugate transpose of another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies the transpose of this matrix with another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies the transpose of this matrix with another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies the transpose of this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + + + + Multiplies the conjugate transpose of this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + + + + Divides each element of the matrix by a scalar and places results into the result matrix. + + The scalar to divide the matrix with. + The matrix to store the result of the division. + + + + Divides a scalar by each element of the matrix and stores the result in the result matrix. + + The scalar to add. + The matrix to store the result of the division. + + + + Computes the determinant of this matrix. + + The determinant of this matrix. + + + + Returns the elements of the diagonal in a . + + The elements of the diagonal. + For non-square matrices, the method returns Min(Rows, Columns) elements where + i == j (i is the row index, and j is the column index). + + + + Copies the values of the given array to the diagonal. + + The array to copy the values from. The length of the vector should be + Min(Rows, Columns). + If the length of does not + equal Min(Rows, Columns). + For non-square matrices, the elements of are copied to + this[i,i]. + + + + Copies the values of the given to the diagonal. + + The vector to copy the values from. The length of the vector should be + Min(Rows, Columns). + If the length of does not + equal Min(Rows, Columns). + For non-square matrices, the elements of are copied to + this[i,i]. + + + Calculates the induced L1 norm of this matrix. + The maximum absolute column sum of the matrix. + + + Calculates the induced L2 norm of the matrix. + The largest singular value of the matrix. + + + Calculates the induced infinity norm of this matrix. + The maximum absolute row sum of the matrix. + + + Calculates the entry-wise Frobenius norm of this matrix. + The square root of the sum of the squared values. + + + Calculates the condition number of this matrix. + The condition number of the matrix. + + + Computes the inverse of this matrix. + If is not a square matrix. + If is singular. + The inverse of this matrix. + + + + Returns a new matrix containing the lower triangle of this matrix. + + The lower triangle of this matrix. + + + + Puts the lower triangle of this matrix into the result matrix. + + Where to store the lower triangle. + If the result matrix's dimensions are not the same as this matrix. + + + + Returns a new matrix containing the lower triangle of this matrix. The new matrix + does not contain the diagonal elements of this matrix. + + The lower triangle of this matrix. + + + + Puts the strictly lower triangle of this matrix into the result matrix. + + Where to store the lower triangle. + If the result matrix's dimensions are not the same as this matrix. + + + + Returns a new matrix containing the upper triangle of this matrix. + + The upper triangle of this matrix. + + + + Puts the upper triangle of this matrix into the result matrix. + + Where to store the lower triangle. + If the result matrix's dimensions are not the same as this matrix. + + + + Returns a new matrix containing the upper triangle of this matrix. The new matrix + does not contain the diagonal elements of this matrix. + + The upper triangle of this matrix. + + + + Puts the strictly upper triangle of this matrix into the result matrix. + + Where to store the lower triangle. + If the result matrix's dimensions are not the same as this matrix. + + + + Creates a matrix that contains the values from the requested sub-matrix. + + The row to start copying from. + The number of rows to copy. Must be positive. + The column to start copying from. + The number of columns to copy. Must be positive. + The requested sub-matrix. + If: is + negative, or greater than or equal to the number of rows. + is negative, or greater than or equal to the number + of columns. + (columnIndex + columnLength) >= Columns + (rowIndex + rowLength) >= Rows + If or + is not positive. + + + + Permute the columns of a matrix according to a permutation. + + The column permutation to apply to this matrix. + Always thrown + Permutation in diagonal matrix are senseless, because of matrix nature + + + + Permute the rows of a matrix according to a permutation. + + The row permutation to apply to this matrix. + Always thrown + Permutation in diagonal matrix are senseless, because of matrix nature + + + + Evaluates whether this matrix is symmetric. + + + + + Evaluates whether this matrix is Hermitian (conjugate symmetric). + + + + + A class which encapsulates the functionality of a Cholesky factorization. + For a symmetric, positive definite matrix A, the Cholesky factorization + is an lower triangular matrix L so that A = L*L'. + + + The computation of the Cholesky factorization is done at construction time. If the matrix is not symmetric + or positive definite, the constructor will throw an exception. + + + + + Gets the determinant of the matrix for which the Cholesky matrix was computed. + + + + + Gets the log determinant of the matrix for which the Cholesky matrix was computed. + + + + + A class which encapsulates the functionality of a Cholesky factorization for dense matrices. + For a symmetric, positive definite matrix A, the Cholesky factorization + is an lower triangular matrix L so that A = L*L'. + + + The computation of the Cholesky factorization is done at construction time. If the matrix is not symmetric + or positive definite, the constructor will throw an exception. + + + + + Initializes a new instance of the class. This object will compute the + Cholesky factorization when the constructor is called and cache it's factorization. + + The matrix to factor. + If is null. + If is not a square matrix. + If is not positive definite. + + + + Solves a system of linear equations, AX = B, with A Cholesky factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A Cholesky factorized. + + The right hand side vector, b. + The left hand side , x. + + + + Calculates the Cholesky factorization of the input matrix. + + The matrix to be factorized. + If is null. + If is not a square matrix. + If is not positive definite. + If does not have the same dimensions as the existing factor. + + + + Eigenvalues and eigenvectors of a complex matrix. + + + If A is Hermitian, then A = V*D*V' where the eigenvalue matrix D is + diagonal and the eigenvector matrix V is Hermitian. + I.e. A = V*D*V' and V*VH=I. + If A is not symmetric, then the eigenvalue matrix D is block diagonal + with the real eigenvalues in 1-by-1 blocks and any complex eigenvalues, + lambda + i*mu, in 2-by-2 blocks, [lambda, mu; -mu, lambda]. The + columns of V represent the eigenvectors in the sense that A*V = V*D, + i.e. A.Multiply(V) equals V.Multiply(D). The matrix V may be badly + conditioned, or even singular, so the validity of the equation + A = V*D*Inverse(V) depends upon V.Condition(). + + + + + Initializes a new instance of the class. This object will compute the + the eigenvalue decomposition when the constructor is called and cache it's decomposition. + + The matrix to factor. + If it is known whether the matrix is symmetric or not the routine can skip checking it itself. + If is null. + If EVD algorithm failed to converge with matrix . + + + + Solves a system of linear equations, AX = B, with A SVD factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A EVD factorized. + + The right hand side vector, b. + The left hand side , x. + + + + A class which encapsulates the functionality of the QR decomposition Modified Gram-Schmidt Orthogonalization. + Any complex square matrix A may be decomposed as A = QR where Q is an unitary mxn matrix and R is an nxn upper triangular matrix. + + + The computation of the QR decomposition is done at construction time by modified Gram-Schmidt Orthogonalization. + + + + + Initializes a new instance of the class. This object creates an unitary matrix + using the modified Gram-Schmidt method. + + The matrix to factor. + If is null. + If row count is less then column count + If is rank deficient + + + + Factorize matrix using the modified Gram-Schmidt method. + + Initial matrix. On exit is replaced by Q. + Number of rows in Q. + Number of columns in Q. + On exit is filled by R. + + + + Solves a system of linear equations, AX = B, with A QR factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A QR factorized. + + The right hand side vector, b. + The left hand side , x. + + + + A class which encapsulates the functionality of an LU factorization. + For a matrix A, the LU factorization is a pair of lower triangular matrix L and + upper triangular matrix U so that A = L*U. + + + The computation of the LU factorization is done at construction time. + + + + + Initializes a new instance of the class. This object will compute the + LU factorization when the constructor is called and cache it's factorization. + + The matrix to factor. + If is null. + If is not a square matrix. + + + + Solves a system of linear equations, AX = B, with A LU factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A LU factorized. + + The right hand side vector, b. + The left hand side , x. + + + + Returns the inverse of this matrix. The inverse is calculated using LU decomposition. + + The inverse of this matrix. + + + + A class which encapsulates the functionality of the QR decomposition. + Any real square matrix A may be decomposed as A = QR where Q is an orthogonal matrix + (its columns are orthogonal unit vectors meaning QTQ = I) and R is an upper triangular matrix + (also called right triangular matrix). + + + The computation of the QR decomposition is done at construction time by Householder transformation. + + + + + Gets or sets Tau vector. Contains additional information on Q - used for native solver. + + + + + Initializes a new instance of the class. This object will compute the + QR factorization when the constructor is called and cache it's factorization. + + The matrix to factor. + The QR factorization method to use. + If is null. + If row count is less then column count + + + + Solves a system of linear equations, AX = B, with A QR factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A QR factorized. + + The right hand side vector, b. + The left hand side , x. + + + + A class which encapsulates the functionality of the singular value decomposition (SVD) for . + Suppose M is an m-by-n matrix whose entries are real numbers. + Then there exists a factorization of the form M = UΣVT where: + - U is an m-by-m unitary matrix; + - Σ is m-by-n diagonal matrix with nonnegative real numbers on the diagonal; + - VT denotes transpose of V, an n-by-n unitary matrix; + Such a factorization is called a singular-value decomposition of M. A common convention is to order the diagonal + entries Σ(i,i) in descending order. In this case, the diagonal matrix Σ is uniquely determined + by M (though the matrices U and V are not). The diagonal entries of Σ are known as the singular values of M. + + + The computation of the singular value decomposition is done at construction time. + + + + + Initializes a new instance of the class. This object will compute the + the singular value decomposition when the constructor is called and cache it's decomposition. + + The matrix to factor. + Compute the singular U and VT vectors or not. + If is null. + If SVD algorithm failed to converge with matrix . + + + + Solves a system of linear equations, AX = B, with A SVD factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A SVD factorized. + + The right hand side vector, b. + The left hand side , x. + + + + Eigenvalues and eigenvectors of a real matrix. + + + If A is symmetric, then A = V*D*V' where the eigenvalue matrix D is + diagonal and the eigenvector matrix V is orthogonal. + I.e. A = V*D*V' and V*VT=I. + If A is not symmetric, then the eigenvalue matrix D is block diagonal + with the real eigenvalues in 1-by-1 blocks and any complex eigenvalues, + lambda + i*mu, in 2-by-2 blocks, [lambda, mu; -mu, lambda]. The + columns of V represent the eigenvectors in the sense that A*V = V*D, + i.e. A.Multiply(V) equals V.Multiply(D). The matrix V may be badly + conditioned, or even singular, so the validity of the equation + A = V*D*Inverse(V) depends upon V.Condition(). + + + + + Gets the absolute value of determinant of the square matrix for which the EVD was computed. + + + + + Gets the effective numerical matrix rank. + + The number of non-negligible singular values. + + + + Gets a value indicating whether the matrix is full rank or not. + + true if the matrix is full rank; otherwise false. + + + + A class which encapsulates the functionality of the QR decomposition Modified Gram-Schmidt Orthogonalization. + Any real square matrix A may be decomposed as A = QR where Q is an orthogonal mxn matrix and R is an nxn upper triangular matrix. + + + The computation of the QR decomposition is done at construction time by modified Gram-Schmidt Orthogonalization. + + + + + Gets the absolute determinant value of the matrix for which the QR matrix was computed. + + + + + Gets a value indicating whether the matrix is full rank or not. + + true if the matrix is full rank; otherwise false. + + + + A class which encapsulates the functionality of an LU factorization. + For a matrix A, the LU factorization is a pair of lower triangular matrix L and + upper triangular matrix U so that A = L*U. + In the Math.NET implementation we also store a set of pivot elements for increased + numerical stability. The pivot elements encode a permutation matrix P such that P*A = L*U. + + + The computation of the LU factorization is done at construction time. + + + + + Gets the determinant of the matrix for which the LU factorization was computed. + + + + + A class which encapsulates the functionality of the QR decomposition. + Any real square matrix A (m x n) may be decomposed as A = QR where Q is an orthogonal matrix + (its columns are orthogonal unit vectors meaning QTQ = I) and R is an upper triangular matrix + (also called right triangular matrix). + + + The computation of the QR decomposition is done at construction time by Householder transformation. + If a factorization is performed, the resulting Q matrix is an m x m matrix + and the R matrix is an m x n matrix. If a factorization is performed, the + resulting Q matrix is an m x n matrix and the R matrix is an n x n matrix. + + + + + Gets the absolute determinant value of the matrix for which the QR matrix was computed. + + + + + Gets a value indicating whether the matrix is full rank or not. + + true if the matrix is full rank; otherwise false. + + + + A class which encapsulates the functionality of the singular value decomposition (SVD). + Suppose M is an m-by-n matrix whose entries are real numbers. + Then there exists a factorization of the form M = UΣVT where: + - U is an m-by-m unitary matrix; + - Σ is m-by-n diagonal matrix with nonnegative real numbers on the diagonal; + - VT denotes transpose of V, an n-by-n unitary matrix; + Such a factorization is called a singular-value decomposition of M. A common convention is to order the diagonal + entries Σ(i,i) in descending order. In this case, the diagonal matrix Σ is uniquely determined + by M (though the matrices U and V are not). The diagonal entries of Σ are known as the singular values of M. + + + The computation of the singular value decomposition is done at construction time. + + + + + Gets the effective numerical matrix rank. + + The number of non-negligible singular values. + + + + Gets the two norm of the . + + The 2-norm of the . + + + + Gets the condition number max(S) / min(S) + + The condition number. + + + + Gets the determinant of the square matrix for which the SVD was computed. + + + + + A class which encapsulates the functionality of a Cholesky factorization for user matrices. + For a symmetric, positive definite matrix A, the Cholesky factorization + is an lower triangular matrix L so that A = L*L'. + + + The computation of the Cholesky factorization is done at construction time. If the matrix is not symmetric + or positive definite, the constructor will throw an exception. + + + + + Computes the Cholesky factorization in-place. + + On entry, the matrix to factor. On exit, the Cholesky factor matrix + If is null. + If is not a square matrix. + If is not positive definite. + + + + Initializes a new instance of the class. This object will compute the + Cholesky factorization when the constructor is called and cache it's factorization. + + The matrix to factor. + If is null. + If is not a square matrix. + If is not positive definite. + + + + Calculates the Cholesky factorization of the input matrix. + + The matrix to be factorized. + If is null. + If is not a square matrix. + If is not positive definite. + If does not have the same dimensions as the existing factor. + + + + Calculate Cholesky step + + Factor matrix + Number of rows + Column start + Total columns + Multipliers calculated previously + Number of available processors + + + + Solves a system of linear equations, AX = B, with A Cholesky factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A Cholesky factorized. + + The right hand side vector, b. + The left hand side , x. + + + + Eigenvalues and eigenvectors of a complex matrix. + + + If A is Hermitian, then A = V*D*V' where the eigenvalue matrix D is + diagonal and the eigenvector matrix V is Hermitian. + I.e. A = V*D*V' and V*VH=I. + If A is not symmetric, then the eigenvalue matrix D is block diagonal + with the real eigenvalues in 1-by-1 blocks and any complex eigenvalues, + lambda + i*mu, in 2-by-2 blocks, [lambda, mu; -mu, lambda]. The + columns of V represent the eigenvectors in the sense that A*V = V*D, + i.e. A.Multiply(V) equals V.Multiply(D). The matrix V may be badly + conditioned, or even singular, so the validity of the equation + A = V*D*Inverse(V) depends upon V.Condition(). + + + + + Initializes a new instance of the class. This object will compute the + the eigenvalue decomposition when the constructor is called and cache it's decomposition. + + The matrix to factor. + If it is known whether the matrix is symmetric or not the routine can skip checking it itself. + If is null. + If EVD algorithm failed to converge with matrix . + + + + Reduces a complex Hermitian matrix to a real symmetric tridiagonal matrix using unitary similarity transformations. + + Source matrix to reduce + Output: Arrays for internal storage of real parts of eigenvalues + Output: Arrays for internal storage of imaginary parts of eigenvalues + Output: Arrays that contains further information about the transformations. + Order of initial matrix + This is derived from the Algol procedures HTRIDI by + Smith, Boyle, Dongarra, Garbow, Ikebe, Klema, Moler, and Wilkinson, Handbook for + Auto. Comp., Vol.ii-Linear Algebra, and the corresponding + Fortran subroutine in EISPACK. + + + + Symmetric tridiagonal QL algorithm. + + The eigen vectors to work on. + Arrays for internal storage of real parts of eigenvalues + Arrays for internal storage of imaginary parts of eigenvalues + Order of initial matrix + This is derived from the Algol procedures tql2, by + Bowdler, Martin, Reinsch, and Wilkinson, Handbook for + Auto. Comp., Vol.ii-Linear Algebra, and the corresponding + Fortran subroutine in EISPACK. + + + + + Determines eigenvectors by undoing the symmetric tridiagonalize transformation + + The eigen vectors to work on. + Previously tridiagonalized matrix by . + Contains further information about the transformations + Input matrix order + This is derived from the Algol procedures HTRIBK, by + by Smith, Boyle, Dongarra, Garbow, Ikebe, Klema, Moler, and Wilkinson, Handbook for + Auto. Comp., Vol.ii-Linear Algebra, and the corresponding + Fortran subroutine in EISPACK. + + + + Nonsymmetric reduction to Hessenberg form. + + The eigen vectors to work on. + Array for internal storage of nonsymmetric Hessenberg form. + Order of initial matrix + This is derived from the Algol procedures orthes and ortran, + by Martin and Wilkinson, Handbook for Auto. Comp., + Vol.ii-Linear Algebra, and the corresponding + Fortran subroutines in EISPACK. + + + + Nonsymmetric reduction from Hessenberg to real Schur form. + + The eigen vectors to work on. + The eigen values to work on. + Array for internal storage of nonsymmetric Hessenberg form. + Order of initial matrix + This is derived from the Algol procedure hqr2, + by Martin and Wilkinson, Handbook for Auto. Comp., + Vol.ii-Linear Algebra, and the corresponding + Fortran subroutine in EISPACK. + + + + Solves a system of linear equations, AX = B, with A SVD factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A EVD factorized. + + The right hand side vector, b. + The left hand side , x. + + + + A class which encapsulates the functionality of the QR decomposition Modified Gram-Schmidt Orthogonalization. + Any complex square matrix A may be decomposed as A = QR where Q is an unitary mxn matrix and R is an nxn upper triangular matrix. + + + The computation of the QR decomposition is done at construction time by modified Gram-Schmidt Orthogonalization. + + + + + Initializes a new instance of the class. This object creates an unitary matrix + using the modified Gram-Schmidt method. + + The matrix to factor. + If is null. + If row count is less then column count + If is rank deficient + + + + Solves a system of linear equations, AX = B, with A QR factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A QR factorized. + + The right hand side vector, b. + The left hand side , x. + + + + A class which encapsulates the functionality of an LU factorization. + For a matrix A, the LU factorization is a pair of lower triangular matrix L and + upper triangular matrix U so that A = L*U. + + + The computation of the LU factorization is done at construction time. + + + + + Initializes a new instance of the class. This object will compute the + LU factorization when the constructor is called and cache it's factorization. + + The matrix to factor. + If is null. + If is not a square matrix. + + + + Solves a system of linear equations, AX = B, with A LU factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A LU factorized. + + The right hand side vector, b. + The left hand side , x. + + + + Returns the inverse of this matrix. The inverse is calculated using LU decomposition. + + The inverse of this matrix. + + + + A class which encapsulates the functionality of the QR decomposition. + Any real square matrix A may be decomposed as A = QR where Q is an orthogonal matrix + (its columns are orthogonal unit vectors meaning QTQ = I) and R is an upper triangular matrix + (also called right triangular matrix). + + + The computation of the QR decomposition is done at construction time by Householder transformation. + + + + + Initializes a new instance of the class. This object will compute the + QR factorization when the constructor is called and cache it's factorization. + + The matrix to factor. + The QR factorization method to use. + If is null. + + + + Generate column from initial matrix to work array + + Initial matrix + The first row + Column index + Generated vector + + + + Perform calculation of Q or R + + Work array + Q or R matrices + The first row + The last row + The first column + The last column + Number of available CPUs + + + + Solves a system of linear equations, AX = B, with A QR factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A QR factorized. + + The right hand side vector, b. + The left hand side , x. + + + + A class which encapsulates the functionality of the singular value decomposition (SVD) for . + Suppose M is an m-by-n matrix whose entries are real numbers. + Then there exists a factorization of the form M = UΣVT where: + - U is an m-by-m unitary matrix; + - Σ is m-by-n diagonal matrix with nonnegative real numbers on the diagonal; + - VT denotes transpose of V, an n-by-n unitary matrix; + Such a factorization is called a singular-value decomposition of M. A common convention is to order the diagonal + entries Σ(i,i) in descending order. In this case, the diagonal matrix Σ is uniquely determined + by M (though the matrices U and V are not). The diagonal entries of Σ are known as the singular values of M. + + + The computation of the singular value decomposition is done at construction time. + + + + + Initializes a new instance of the class. This object will compute the + the singular value decomposition when the constructor is called and cache it's decomposition. + + The matrix to factor. + Compute the singular U and VT vectors or not. + If is null. + + + + + Calculates absolute value of multiplied on signum function of + + Complex32 value z1 + Complex32 value z2 + Result multiplication of signum function and absolute value + + + + Interchanges two vectors and + + Source matrix + The number of rows in + Column A index to swap + Column B index to swap + + + + Scale column by starting from row + + Source matrix + The number of rows in + Column to scale + Row to scale from + Scale value + + + + Scale vector by starting from index + + Source vector + Row to scale from + Scale value + + + + Given the Cartesian coordinates (da, db) of a point p, these function return the parameters da, db, c, and s + associated with the Givens rotation that zeros the y-coordinate of the point. + + Provides the x-coordinate of the point p. On exit contains the parameter r associated with the Givens rotation + Provides the y-coordinate of the point p. On exit contains the parameter z associated with the Givens rotation + Contains the parameter c associated with the Givens rotation + Contains the parameter s associated with the Givens rotation + This is equivalent to the DROTG LAPACK routine. + + + + Calculate Norm 2 of the column in matrix starting from row + + Source matrix + The number of rows in + Column index + Start row index + Norm2 (Euclidean norm) of the column + + + + Calculate Norm 2 of the vector starting from index + + Source vector + Start index + Norm2 (Euclidean norm) of the vector + + + + Calculate dot product of and conjugating the first vector. + + Source matrix + The number of rows in + Index of column A + Index of column B + Starting row index + Dot product value + + + + Performs rotation of points in the plane. Given two vectors x and y , + each vector element of these vectors is replaced as follows: x(i) = c*x(i) + s*y(i); y(i) = c*y(i) - s*x(i) + + Source matrix + The number of rows in + Index of column A + Index of column B + scalar cos value + scalar sin value + + + + Solves a system of linear equations, AX = B, with A SVD factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A SVD factorized. + + The right hand side vector, b. + The left hand side , x. + + + + Complex32 version of the class. + + + + + Initializes a new instance of the Matrix class. + + + + + Set all values whose absolute value is smaller than the threshold to zero. + + + + + Returns the conjugate transpose of this matrix. + + The conjugate transpose of this matrix. + + + + Puts the conjugate transpose of this matrix into the result matrix. + + + + + Complex conjugates each element of this matrix and place the results into the result matrix. + + The result of the conjugation. + + + + Negate each element of this matrix and place the results into the result matrix. + + The result of the negation. + + + + Add a scalar to each element of the matrix and stores the result in the result vector. + + The scalar to add. + The matrix to store the result of the addition. + + + + Adds another matrix to this matrix. + + The matrix to add to this matrix. + The matrix to store the result of the addition. + If the other matrix is . + If the two matrices don't have the same dimensions. + + + + Subtracts a scalar from each element of the vector and stores the result in the result vector. + + The scalar to subtract. + The matrix to store the result of the subtraction. + + + + Subtracts another matrix from this matrix. + + The matrix to subtract to this matrix. + The matrix to store the result of subtraction. + If the other matrix is . + If the two matrices don't have the same dimensions. + + + + Multiplies each element of the matrix by a scalar and places results into the result matrix. + + The scalar to multiply the matrix with. + The matrix to store the result of the multiplication. + + + + Multiplies this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + + + + Divides each element of the matrix by a scalar and places results into the result matrix. + + The scalar to divide the matrix with. + The matrix to store the result of the division. + + + + Divides a scalar by each element of the matrix and stores the result in the result matrix. + + The scalar to divide by each element of the matrix. + The matrix to store the result of the division. + + + + Multiplies this matrix with another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies this matrix with transpose of another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies this matrix with the conjugate transpose of another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies the transpose of this matrix with another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies the transpose of this matrix with another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies the transpose of this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + + + + Multiplies the conjugate transpose of this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + + + + Pointwise multiplies this matrix with another matrix and stores the result into the result matrix. + + The matrix to pointwise multiply with this one. + The matrix to store the result of the pointwise multiplication. + + + + Pointwise divide this matrix by another matrix and stores the result into the result matrix. + + The matrix to pointwise divide this one by. + The matrix to store the result of the pointwise division. + + + + Pointwise raise this matrix to an exponent and store the result into the result matrix. + + The exponent to raise this matrix values to. + The matrix to store the result of the pointwise power. + + + + Pointwise raise this matrix to an exponent and store the result into the result matrix. + + The exponent to raise this matrix values to. + The vector to store the result of the pointwise power. + + + + Pointwise canonical modulus, where the result has the sign of the divisor, + of this matrix with another matrix and stores the result into the result matrix. + + The pointwise denominator matrix to use + The result of the modulus. + + + + Pointwise remainder (% operator), where the result has the sign of the dividend, + of this matrix with another matrix and stores the result into the result matrix. + + The pointwise denominator matrix to use + The result of the modulus. + + + + Computes the canonical modulus, where the result has the sign of the divisor, + for the given divisor each element of the matrix. + + The scalar denominator to use. + Matrix to store the results in. + + + + Computes the canonical modulus, where the result has the sign of the divisor, + for the given dividend for each element of the matrix. + + The scalar numerator to use. + A vector to store the results in. + + + + Computes the remainder (% operator), where the result has the sign of the dividend, + for the given divisor each element of the matrix. + + The scalar denominator to use. + Matrix to store the results in. + + + + Computes the remainder (% operator), where the result has the sign of the dividend, + for the given dividend for each element of the matrix. + + The scalar numerator to use. + A vector to store the results in. + + + + Pointwise applies the exponential function to each value and stores the result into the result matrix. + + The matrix to store the result. + + + + Pointwise applies the natural logarithm function to each value and stores the result into the result matrix. + + The matrix to store the result. + + + + Computes the Moore-Penrose Pseudo-Inverse of this matrix. + + + + + Computes the trace of this matrix. + + The trace of this matrix + If the matrix is not square + + + Calculates the induced L1 norm of this matrix. + The maximum absolute column sum of the matrix. + + + Calculates the induced infinity norm of this matrix. + The maximum absolute row sum of the matrix. + + + Calculates the entry-wise Frobenius norm of this matrix. + The square root of the sum of the squared values. + + + + Calculates the p-norms of all row vectors. + Typical values for p are 1.0 (L1, Manhattan norm), 2.0 (L2, Euclidean norm) and positive infinity (infinity norm) + + + + + Calculates the p-norms of all column vectors. + Typical values for p are 1.0 (L1, Manhattan norm), 2.0 (L2, Euclidean norm) and positive infinity (infinity norm) + + + + + Normalizes all row vectors to a unit p-norm. + Typical values for p are 1.0 (L1, Manhattan norm), 2.0 (L2, Euclidean norm) and positive infinity (infinity norm) + + + + + Normalizes all column vectors to a unit p-norm. + Typical values for p are 1.0 (L1, Manhattan norm), 2.0 (L2, Euclidean norm) and positive infinity (infinity norm) + + + + + Calculates the value sum of each row vector. + + + + + Calculates the absolute value sum of each row vector. + + + + + Calculates the value sum of each column vector. + + + + + Calculates the absolute value sum of each column vector. + + + + + Evaluates whether this matrix is Hermitian (conjugate symmetric). + + + + + A Bi-Conjugate Gradient stabilized iterative matrix solver. + + + + The Bi-Conjugate Gradient Stabilized (BiCGStab) solver is an 'improvement' + of the standard Conjugate Gradient (CG) solver. Unlike the CG solver the + BiCGStab can be used on non-symmetric matrices.
    + Note that much of the success of the solver depends on the selection of the + proper preconditioner. +     + + The Bi-CGSTAB algorithm was taken from:
    + Templates for the solution of linear systems: Building blocks + for iterative methods +
    + Richard Barrett, Michael Berry, Tony F. Chan, James Demmel, + June M. Donato, Jack Dongarra, Victor Eijkhout, Roldan Pozo, + Charles Romine and Henk van der Vorst +
    + Url: http://www.netlib.org/templates/Templates.html +
    + Algorithm is described in Chapter 2, section 2.3.8, page 27 +     + + The example code below provides an indication of the possible use of the + solver. + +     +     + + + Calculates the true residual of the matrix equation Ax = b according to: residual = b - Ax + + Instance of the A. + Residual values in . + Instance of the x. + Instance of the b. + + + + Solves the matrix equation Ax = b, where A is the coefficient matrix, b is the + solution vector and x is the unknown vector. + + The coefficient , A. + The solution , b. + The result , x. + The iterator to use to control when to stop iterating. + The preconditioner to use for approximations. + + + + A composite matrix solver. The actual solver is made by a sequence of + matrix solvers. + + + + Solver based on:
    + Faster PDE-based simulations using robust composite linear solvers
    + S. Bhowmicka, P. Raghavan a,*, L. McInnes b, B. Norris
    + Future Generation Computer Systems, Vol 20, 2004, pp 373�387
    +     + + Note that if an iterator is passed to this solver it will be used for all the sub-solvers. + +     +     + + + The collection of solvers that will be used + + + + + Solves the matrix equation Ax = b, where A is the coefficient matrix, b is the + solution vector and x is the unknown vector. + + The coefficient matrix, A. + The solution vector, b + The result vector, x + The iterator to use to control when to stop iterating. + The preconditioner to use for approximations. + + + + A diagonal preconditioner. The preconditioner uses the inverse + of the matrix diagonal as preconditioning values. + + + + + The inverse of the matrix diagonal. + + + + + Returns the decomposed matrix diagonal. + + The matrix diagonal. + + + + Initializes the preconditioner and loads the internal data structures. + + + The upon which this preconditioner is based. + If is . + If is not a square matrix. + + + + Approximates the solution to the matrix equation Ax = b. + + The right hand side vector. + The left hand side vector. Also known as the result vector. + + + + A Generalized Product Bi-Conjugate Gradient iterative matrix solver. + + + + The Generalized Product Bi-Conjugate Gradient (GPBiCG) solver is an + alternative version of the Bi-Conjugate Gradient stabilized (CG) solver. + Unlike the CG solver the GPBiCG solver can be used on + non-symmetric matrices.
    + Note that much of the success of the solver depends on the selection of the + proper preconditioner. +     + + The GPBiCG algorithm was taken from:
    + GPBiCG(m,l): A hybrid of BiCGSTAB and GPBiCG methods with + efficiency and robustness +
    + S. Fujino +
    + Applied Numerical Mathematics, Volume 41, 2002, pp 107 - 117 +
    +     + + The example code below provides an indication of the possible use of the + solver. + +     +     + + + Indicates the number of BiCGStab steps should be taken + before switching. + + + + + Indicates the number of GPBiCG steps should be taken + before switching. + + + + + Gets or sets the number of steps taken with the BiCgStab algorithm + before switching over to the GPBiCG algorithm. + + + + + Gets or sets the number of steps taken with the GPBiCG algorithm + before switching over to the BiCgStab algorithm. + + + + + Calculates the true residual of the matrix equation Ax = b according to: residual = b - Ax + + Instance of the A. + Residual values in . + Instance of the x. + Instance of the b. + + + + Decide if to do steps with BiCgStab + + Number of iteration + true if yes, otherwise false + + + + Solves the matrix equation Ax = b, where A is the coefficient matrix, b is the + solution vector and x is the unknown vector. + + The coefficient matrix, A. + The solution vector, b + The result vector, x + The iterator to use to control when to stop iterating. + The preconditioner to use for approximations. + + + + An incomplete, level 0, LU factorization preconditioner. + + + The ILU(0) algorithm was taken from:
    + Iterative methods for sparse linear systems
    + Yousef Saad
    + Algorithm is described in Chapter 10, section 10.3.2, page 275
    +     +     + + + The matrix holding the lower (L) and upper (U) matrices. The + decomposition matrices are combined to reduce storage. + + + + + Returns the upper triagonal matrix that was created during the LU decomposition. + + A new matrix containing the upper triagonal elements. + + + + Returns the lower triagonal matrix that was created during the LU decomposition. + + A new matrix containing the lower triagonal elements. + + + + Initializes the preconditioner and loads the internal data structures. + + The matrix upon which the preconditioner is based. + If is . + If is not a square matrix. + + + + Approximates the solution to the matrix equation Ax = b. + + The right hand side vector. + The left hand side vector. Also known as the result vector. + + + + This class performs an Incomplete LU factorization with drop tolerance + and partial pivoting. The drop tolerance indicates which additional entries + will be dropped from the factorized LU matrices. + + + The ILUTP-Mem algorithm was taken from:
    + ILUTP_Mem: a Space-Efficient Incomplete LU Preconditioner +
    + Tzu-Yi Chen, Department of Mathematics and Computer Science,
    + Pomona College, Claremont CA 91711, USA
    + Published in:
    + Lecture Notes in Computer Science
    + Volume 3046 / 2004
    + pp. 20 - 28
    + Algorithm is described in Section 2, page 22 +     +     + + + The default fill level. + + + + + The default drop tolerance. + + + + + The decomposed upper triangular matrix. + + + + + The decomposed lower triangular matrix. + + + + + The array containing the pivot values. + + + + + The fill level. + + + + + The drop tolerance. + + + + + The pivot tolerance. + + + + + Initializes a new instance of the class with the default settings. + + + + + Initializes a new instance of the class with the specified settings. + + + The amount of fill that is allowed in the matrix. The value is a fraction of + the number of non-zero entries in the original matrix. Values should be positive. + + + The absolute drop tolerance which indicates below what absolute value an entry + will be dropped from the matrix. A drop tolerance of 0.0 means that no values + will be dropped. Values should always be positive. + + + The pivot tolerance which indicates at what level pivoting will take place. A + value of 0.0 means that no pivoting will take place. + + + + + Gets or sets the amount of fill that is allowed in the matrix. The + value is a fraction of the number of non-zero entries in the original + matrix. The standard value is 200. + + + + Values should always be positive and can be higher than 1.0. A value lower + than 1.0 means that the eventual preconditioner matrix will have fewer + non-zero entries as the original matrix. A value higher than 1.0 means that + the eventual preconditioner can have more non-zero values than the original + matrix. + + + Note that any changes to the FillLevel after creating the preconditioner + will invalidate the created preconditioner and will require a re-initialization of + the preconditioner. + + + Thrown if a negative value is provided. + + + + Gets or sets the absolute drop tolerance which indicates below what absolute value + an entry will be dropped from the matrix. The standard value is 0.0001. + + + + The values should always be positive and can be larger than 1.0. A low value will + keep more small numbers in the preconditioner matrix. A high value will remove + more small numbers from the preconditioner matrix. + + + Note that any changes to the DropTolerance after creating the preconditioner + will invalidate the created preconditioner and will require a re-initialization of + the preconditioner. + + + Thrown if a negative value is provided. + + + + Gets or sets the pivot tolerance which indicates at what level pivoting will + take place. The standard value is 0.0 which means pivoting will never take place. + + + + The pivot tolerance is used to calculate if pivoting is necessary. Pivoting + will take place if any of the values in a row is bigger than the + diagonal value of that row divided by the pivot tolerance, i.e. pivoting + will take place if row(i,j) > row(i,i) / PivotTolerance for + any j that is not equal to i. + + + Note that any changes to the PivotTolerance after creating the preconditioner + will invalidate the created preconditioner and will require a re-initialization of + the preconditioner. + + + Thrown if a negative value is provided. + + + + Returns the upper triagonal matrix that was created during the LU decomposition. + + + This method is used for debugging purposes only and should normally not be used. + + A new matrix containing the upper triagonal elements. + + + + Returns the lower triagonal matrix that was created during the LU decomposition. + + + This method is used for debugging purposes only and should normally not be used. + + A new matrix containing the lower triagonal elements. + + + + Returns the pivot array. This array is not needed for normal use because + the preconditioner will return the solution vector values in the proper order. + + + This method is used for debugging purposes only and should normally not be used. + + The pivot array. + + + + Initializes the preconditioner and loads the internal data structures. + + + The upon which this preconditioner is based. Note that the + method takes a general matrix type. However internally the data is stored + as a sparse matrix. Therefore it is not recommended to pass a dense matrix. + + If is . + If is not a square matrix. + + + + Pivot elements in the according to internal pivot array + + Row to pivot in + + + + Was pivoting already performed + + Pivots already done + Current item to pivot + true if performed, otherwise false + + + + Swap columns in the + + Source . + First column index to swap + Second column index to swap + + + + Sort vector descending, not changing vector but placing sorted indices to + + Start sort form + Sort till upper bound + Array with sorted vector indices + Source + + + + Approximates the solution to the matrix equation Ax = b. + + The right hand side vector. + The left hand side vector. Also known as the result vector. + + + + Pivot elements in according to internal pivot array + + Source . + Result after pivoting. + + + + An element sort algorithm for the class. + + + This sort algorithm is used to sort the columns in a sparse matrix based on + the value of the element on the diagonal of the matrix. + + + + + Sorts the elements of the vector in decreasing + fashion. The vector itself is not affected. + + The starting index. + The stopping index. + An array that will contain the sorted indices once the algorithm finishes. + The that contains the values that need to be sorted. + + + + Sorts the elements of the vector in decreasing + fashion using heap sort algorithm. The vector itself is not affected. + + The starting index. + The stopping index. + An array that will contain the sorted indices once the algorithm finishes. + The that contains the values that need to be sorted. + + + + Build heap for double indices + + Root position + Length of + Indices of + Target + + + + Sift double indices + + Indices of + Target + Root position + Length of + + + + Sorts the given integers in a decreasing fashion. + + The values. + + + + Sort the given integers in a decreasing fashion using heapsort algorithm + + Array of values to sort + Length of + + + + Build heap + + Target values array + Root position + Length of + + + + Sift values + + Target value array + Root position + Length of + + + + Exchange values in array + + Target values array + First value to exchange + Second value to exchange + + + + A simple milu(0) preconditioner. + + + Original Fortran code by Yousef Saad (07 January 2004) + + + + Use modified or standard ILU(0) + + + + Gets or sets a value indicating whether to use modified or standard ILU(0). + + + + + Gets a value indicating whether the preconditioner is initialized. + + + + + Initializes the preconditioner and loads the internal data structures. + + The matrix upon which the preconditioner is based. + If is . + If is not a square or is not an + instance of SparseCompressedRowMatrixStorage. + + + + Approximates the solution to the matrix equation Ax = b. + + The right hand side vector b. + The left hand side vector x. + + + + MILU0 is a simple milu(0) preconditioner. + + Order of the matrix. + Matrix values in CSR format (input). + Column indices (input). + Row pointers (input). + Matrix values in MSR format (output). + Row pointers and column indices (output). + Pointer to diagonal elements (output). + True if the modified/MILU algorithm should be used (recommended) + Returns 0 on success or k > 0 if a zero pivot was encountered at step k. + + + + A Multiple-Lanczos Bi-Conjugate Gradient stabilized iterative matrix solver. + + + + The Multiple-Lanczos Bi-Conjugate Gradient stabilized (ML(k)-BiCGStab) solver is an 'improvement' + of the standard BiCgStab solver. + + + The algorithm was taken from:
    + ML(k)BiCGSTAB: A BiCGSTAB variant based on multiple Lanczos starting vectors +
    + Man-Chung Yeung and Tony F. Chan +
    + SIAM Journal of Scientific Computing +
    + Volume 21, Number 4, pp. 1263 - 1290 +     + + The example code below provides an indication of the possible use of the + solver. + +     +     + + + The default number of starting vectors. + + + + + The collection of starting vectors which are used as the basis for the Krylov sub-space. + + + + + The number of starting vectors used by the algorithm + + + + + Gets or sets the number of starting vectors. + + + Must be larger than 1 and smaller than the number of variables in the matrix that + for which this solver will be used. + + + + + Resets the number of starting vectors to the default value. + + + + + Gets or sets a series of orthonormal vectors which will be used as basis for the + Krylov sub-space. + + + + + Gets the number of starting vectors to create + + Maximum number + Number of variables + Number of starting vectors to create + + + + Returns an array of starting vectors. + + The maximum number of starting vectors that should be created. + The number of variables. + + An array with starting vectors. The array will never be larger than the + but it may be smaller if + the is smaller than + the . + + + + + Create random vectors array + + Number of vectors + Size of each vector + Array of random vectors + + + + Calculates the true residual of the matrix equation Ax = b according to: residual = b - Ax + + Source A. + Residual data. + x data. + b data. + + + + Solves the matrix equation Ax = b, where A is the coefficient matrix, b is the + solution vector and x is the unknown vector. + + The coefficient matrix, A. + The solution vector, b + The result vector, x + The iterator to use to control when to stop iterating. + The preconditioner to use for approximations. + + + + A Transpose Free Quasi-Minimal Residual (TFQMR) iterative matrix solver. + + + + The TFQMR algorithm was taken from:
    + Iterative methods for sparse linear systems. +
    + Yousef Saad +
    + Algorithm is described in Chapter 7, section 7.4.3, page 219 +     + + The example code below provides an indication of the possible use of the + solver. + +     +     + + + Calculates the true residual of the matrix equation Ax = b according to: residual = b - Ax + + Instance of the A. + Residual values in . + Instance of the x. + Instance of the b. + + + + Is even? + + Number to check + true if even, otherwise false + + + + Solves the matrix equation Ax = b, where A is the coefficient matrix, b is the + solution vector and x is the unknown vector. + + The coefficient matrix, A. + The solution vector, b + The result vector, x + The iterator to use to control when to stop iterating. + The preconditioner to use for approximations. + + + + A Matrix with sparse storage, intended for very large matrices where most of the cells are zero. + The underlying storage scheme is 3-array compressed-sparse-row (CSR) Format. + Wikipedia - CSR. + + + + + Gets the number of non zero elements in the matrix. + + The number of non zero elements. + + + + Create a new sparse matrix straight from an initialized matrix storage instance. + The storage is used directly without copying. + Intended for advanced scenarios where you're working directly with + storage for performance or interop reasons. + + + + + Create a new square sparse matrix with the given number of rows and columns. + All cells of the matrix will be initialized to zero. + + If the order is less than one. + + + + Create a new sparse matrix with the given number of rows and columns. + All cells of the matrix will be initialized to zero. + + If the row or column count is less than one. + + + + Create a new sparse matrix as a copy of the given other matrix. + This new matrix will be independent from the other matrix. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given two-dimensional array. + This new matrix will be independent from the provided array. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given enumerable. + The enumerable is assumed to be in row-major order (row by row). + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the vector. + + + + + + Create a new sparse matrix with the given number of rows and columns as a copy of the given array. + The array is assumed to be in column-major order (column by column). + This new matrix will be independent from the provided array. + A new memory block will be allocated for storing the matrix. + + + + + + Create a new sparse matrix as a copy of the given enumerable of enumerable columns. + Each enumerable in the master enumerable specifies a column. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given enumerable of enumerable columns. + Each enumerable in the master enumerable specifies a column. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given column arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given column arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given column vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given column vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given enumerable of enumerable rows. + Each enumerable in the master enumerable specifies a row. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given enumerable of enumerable rows. + Each enumerable in the master enumerable specifies a row. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given row arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given row arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given row vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given row vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix with the diagonal as a copy of the given vector. + This new matrix will be independent from the vector. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix with the diagonal as a copy of the given vector. + This new matrix will be independent from the vector. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix with the diagonal as a copy of the given array. + This new matrix will be independent from the array. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix with the diagonal as a copy of the given array. + This new matrix will be independent from the array. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix and initialize each value to the same provided value. + + + + + Create a new sparse matrix and initialize each value using the provided init function. + + + + + Create a new diagonal sparse matrix and initialize each diagonal value to the same provided value. + + + + + Create a new diagonal sparse matrix and initialize each diagonal value using the provided init function. + + + + + Create a new square sparse identity matrix where each diagonal value is set to One. + + + + + Returns a new matrix containing the lower triangle of this matrix. + + The lower triangle of this matrix. + + + + Puts the lower triangle of this matrix into the result matrix. + + Where to store the lower triangle. + If is . + If the result matrix's dimensions are not the same as this matrix. + + + + Puts the lower triangle of this matrix into the result matrix. + + Where to store the lower triangle. + + + + Returns a new matrix containing the upper triangle of this matrix. + + The upper triangle of this matrix. + + + + Puts the upper triangle of this matrix into the result matrix. + + Where to store the lower triangle. + If is . + If the result matrix's dimensions are not the same as this matrix. + + + + Puts the upper triangle of this matrix into the result matrix. + + Where to store the lower triangle. + + + + Returns a new matrix containing the lower triangle of this matrix. The new matrix + does not contain the diagonal elements of this matrix. + + The lower triangle of this matrix. + + + + Puts the strictly lower triangle of this matrix into the result matrix. + + Where to store the lower triangle. + If is . + If the result matrix's dimensions are not the same as this matrix. + + + + Puts the strictly lower triangle of this matrix into the result matrix. + + Where to store the lower triangle. + + + + Returns a new matrix containing the upper triangle of this matrix. The new matrix + does not contain the diagonal elements of this matrix. + + The upper triangle of this matrix. + + + + Puts the strictly upper triangle of this matrix into the result matrix. + + Where to store the lower triangle. + If is . + If the result matrix's dimensions are not the same as this matrix. + + + + Puts the strictly upper triangle of this matrix into the result matrix. + + Where to store the lower triangle. + + + + Negate each element of this matrix and place the results into the result matrix. + + The result of the negation. + + + Calculates the induced infinity norm of this matrix. + The maximum absolute row sum of the matrix. + + + Calculates the entry-wise Frobenius norm of this matrix. + The square root of the sum of the squared values. + + + + Adds another matrix to this matrix. + + The matrix to add to this matrix. + The matrix to store the result of the addition. + If the other matrix is . + If the two matrices don't have the same dimensions. + + + + Subtracts another matrix from this matrix. + + The matrix to subtract to this matrix. + The matrix to store the result of subtraction. + If the other matrix is . + If the two matrices don't have the same dimensions. + + + + Multiplies each element of the matrix by a scalar and places results into the result matrix. + + The scalar to multiply the matrix with. + The matrix to store the result of the multiplication. + + + + Multiplies this matrix with another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + + + + Multiplies this matrix with transpose of another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies the transpose of this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + + + + Pointwise multiplies this matrix with another matrix and stores the result into the result matrix. + + The matrix to pointwise multiply with this one. + The matrix to store the result of the pointwise multiplication. + + + + Pointwise divide this matrix by another matrix and stores the result into the result matrix. + + The matrix to pointwise divide this one by. + The matrix to store the result of the pointwise division. + + + + Evaluates whether this matrix is symmetric. + + + + + Evaluates whether this matrix is Hermitian (conjugate symmetric). + + + + + Adds two matrices together and returns the results. + + This operator will allocate new memory for the result. It will + choose the representation of either or depending on which + is denser. + The left matrix to add. + The right matrix to add. + The result of the addition. + If and don't have the same dimensions. + If or is . + + + + Returns a Matrix containing the same values of . + + The matrix to get the values from. + A matrix containing a the same values as . + If is . + + + + Subtracts two matrices together and returns the results. + + This operator will allocate new memory for the result. It will + choose the representation of either or depending on which + is denser. + The left matrix to subtract. + The right matrix to subtract. + The result of the addition. + If and don't have the same dimensions. + If or is . + + + + Negates each element of the matrix. + + The matrix to negate. + A matrix containing the negated values. + If is . + + + + Multiplies a Matrix by a constant and returns the result. + + The matrix to multiply. + The constant to multiply the matrix by. + The result of the multiplication. + If is . + + + + Multiplies a Matrix by a constant and returns the result. + + The matrix to multiply. + The constant to multiply the matrix by. + The result of the multiplication. + If is . + + + + Multiplies two matrices. + + This operator will allocate new memory for the result. It will + choose the representation of either or depending on which + is denser. + The left matrix to multiply. + The right matrix to multiply. + The result of multiplication. + If or is . + If the dimensions of or don't conform. + + + + Multiplies a Matrix and a Vector. + + The matrix to multiply. + The vector to multiply. + The result of multiplication. + If or is . + + + + Multiplies a Vector and a Matrix. + + The vector to multiply. + The matrix to multiply. + The result of multiplication. + If or is . + + + + Multiplies a Matrix by a constant and returns the result. + + The matrix to multiply. + The constant to multiply the matrix by. + The result of the multiplication. + If is . + + + + A vector with sparse storage, intended for very large vectors where most of the cells are zero. + + The sparse vector is not thread safe. + + + + Gets the number of non zero elements in the vector. + + The number of non zero elements. + + + + Create a new sparse vector straight from an initialized vector storage instance. + The storage is used directly without copying. + Intended for advanced scenarios where you're working directly with + storage for performance or interop reasons. + + + + + Create a new sparse vector with the given length. + All cells of the vector will be initialized to zero. + + If length is less than one. + + + + Create a new sparse vector as a copy of the given other vector. + This new vector will be independent from the other vector. + A new memory block will be allocated for storing the vector. + + + + + Create a new sparse vector as a copy of the given enumerable. + This new vector will be independent from the enumerable. + A new memory block will be allocated for storing the vector. + + + + + Create a new sparse vector as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new vector will be independent from the enumerable. + A new memory block will be allocated for storing the vector. + + + + + Create a new sparse vector as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new vector will be independent from the enumerable. + A new memory block will be allocated for storing the vector. + + + + + Create a new sparse vector and initialize each value using the provided value. + + + + + Create a new sparse vector and initialize each value using the provided init function. + + + + + Adds a scalar to each element of the vector and stores the result in the result vector. + Warning, the new 'sparse vector' with a non-zero scalar added to it will be a 100% filled + sparse vector and very inefficient. Would be better to work with a dense vector instead. + + + The scalar to add. + + + The vector to store the result of the addition. + + + + + Adds another vector to this vector and stores the result into the result vector. + + + The vector to add to this one. + + + The vector to store the result of the addition. + + + + + Subtracts a scalar from each element of the vector and stores the result in the result vector. + + + The scalar to subtract. + + + The vector to store the result of the subtraction. + + + + + Subtracts another vector to this vector and stores the result into the result vector. + + + The vector to subtract from this one. + + + The vector to store the result of the subtraction. + + + + + Negates vector and saves result to + + Target vector + + + + Conjugates vector and save result to + + Target vector + + + + Multiplies a scalar to each element of the vector and stores the result in the result vector. + + + The scalar to multiply. + + + The vector to store the result of the multiplication. + + + + + Computes the dot product between this vector and another vector. + + The other vector. + The sum of a[i]*b[i] for all i. + + + + Computes the dot product between the conjugate of this vector and another vector. + + The other vector. + The sum of conj(a[i])*b[i] for all i. + + + + Adds two Vectors together and returns the results. + + One of the vectors to add. + The other vector to add. + The result of the addition. + If and are not the same size. + If or is . + + + + Returns a Vector containing the negated values of . + + The vector to get the values from. + A vector containing the negated values as . + If is . + + + + Subtracts two Vectors and returns the results. + + The vector to subtract from. + The vector to subtract. + The result of the subtraction. + If and are not the same size. + If or is . + + + + Multiplies a vector with a complex. + + The vector to scale. + The complex value. + The result of the multiplication. + If is . + + + + Multiplies a vector with a complex. + + The complex value. + The vector to scale. + The result of the multiplication. + If is . + + + + Computes the dot product between two Vectors. + + The left row vector. + The right column vector. + The dot product between the two vectors. + If and are not the same size. + If or is . + + + + Divides a vector with a complex. + + The vector to divide. + The complex value. + The result of the division. + If is . + + + + Computes the modulus of each element of the vector of the given divisor. + + The vector whose elements we want to compute the modulus of. + The divisor to use, + The result of the calculation + If is . + + + + Returns the index of the absolute minimum element. + + The index of absolute minimum element. + + + + Returns the index of the absolute maximum element. + + The index of absolute maximum element. + + + + Computes the sum of the vector's elements. + + The sum of the vector's elements. + + + + Calculates the L1 norm of the vector, also known as Manhattan norm. + + The sum of the absolute values. + + + + Calculates the infinity norm of the vector. + + The maximum absolute value. + + + + Computes the p-Norm. + + The p value. + Scalar ret = ( ∑|this[i]|^p )^(1/p) + + + + Pointwise multiplies this vector with another vector and stores the result into the result vector. + + The vector to pointwise multiply with this one. + The vector to store the result of the pointwise multiplication. + + + + Creates a double sparse vector based on a string. The string can be in the following formats (without the + quotes): 'n', 'n;n;..', '(n;n;..)', '[n;n;...]', where n is a Complex32. + + + A double sparse vector containing the values specified by the given string. + + + the string to parse. + + + An that supplies culture-specific formatting information. + + + + + Converts the string representation of a complex sparse vector to double-precision sparse vector equivalent. + A return value indicates whether the conversion succeeded or failed. + + + A string containing a complex vector to convert. + + + The parsed value. + + + If the conversion succeeds, the result will contain a complex number equivalent to value. + Otherwise the result will be null. + + + + + Converts the string representation of a complex sparse vector to double-precision sparse vector equivalent. + A return value indicates whether the conversion succeeded or failed. + + + A string containing a complex vector to convert. + + + An that supplies culture-specific formatting information about value. + + + The parsed value. + + + If the conversion succeeds, the result will contain a complex number equivalent to value. + Otherwise the result will be null. + + + + + Complex32 version of the class. + + + + + Initializes a new instance of the Vector class. + + + + + Set all values whose absolute value is smaller than the threshold to zero. + + + + + Conjugates vector and save result to + + Target vector + + + + Negates vector and saves result to + + Target vector + + + + Adds a scalar to each element of the vector and stores the result in the result vector. + + + The scalar to add. + + + The vector to store the result of the addition. + + + + + Adds another vector to this vector and stores the result into the result vector. + + + The vector to add to this one. + + + The vector to store the result of the addition. + + + + + Subtracts a scalar from each element of the vector and stores the result in the result vector. + + + The scalar to subtract. + + + The vector to store the result of the subtraction. + + + + + Subtracts another vector to this vector and stores the result into the result vector. + + + The vector to subtract from this one. + + + The vector to store the result of the subtraction. + + + + + Multiplies a scalar to each element of the vector and stores the result in the result vector. + + + The scalar to multiply. + + + The vector to store the result of the multiplication. + + + + + Divides each element of the vector by a scalar and stores the result in the result vector. + + + The scalar to divide with. + + + The vector to store the result of the division. + + + + + Divides a scalar by each element of the vector and stores the result in the result vector. + + The scalar to divide. + The vector to store the result of the division. + + + + Pointwise multiplies this vector with another vector and stores the result into the result vector. + + The vector to pointwise multiply with this one. + The vector to store the result of the pointwise multiplication. + + + + Pointwise divide this vector with another vector and stores the result into the result vector. + + The vector to pointwise divide this one by. + The vector to store the result of the pointwise division. + + + + Pointwise raise this vector to an exponent and store the result into the result vector. + + The exponent to raise this vector values to. + The vector to store the result of the pointwise power. + + + + Pointwise raise this vector to an exponent vector and store the result into the result vector. + + The exponent vector to raise this vector values to. + The vector to store the result of the pointwise power. + + + + Pointwise canonical modulus, where the result has the sign of the divisor, + of this vector with another vector and stores the result into the result vector. + + The pointwise denominator vector to use. + The result of the modulus. + + + + Pointwise remainder (% operator), where the result has the sign of the dividend, + of this vector with another vector and stores the result into the result vector. + + The pointwise denominator vector to use. + The result of the modulus. + + + + Pointwise applies the exponential function to each value and stores the result into the result vector. + + The vector to store the result. + + + + Pointwise applies the natural logarithm function to each value and stores the result into the result vector. + + The vector to store the result. + + + + Computes the dot product between this vector and another vector. + + The other vector. + The sum of a[i]*b[i] for all i. + + + + Computes the dot product between the conjugate of this vector and another vector. + + The other vector. + The sum of conj(a[i])*b[i] for all i. + + + + Computes the canonical modulus, where the result has the sign of the divisor, + for each element of the vector for the given divisor. + + The scalar denominator to use. + A vector to store the results in. + + + + Computes the canonical modulus, where the result has the sign of the divisor, + for the given dividend for each element of the vector. + + The scalar numerator to use. + A vector to store the results in. + + + + Computes the remainder (% operator), where the result has the sign of the dividend, + for each element of the vector for the given divisor. + + The scalar denominator to use. + A vector to store the results in. + + + + Computes the remainder (% operator), where the result has the sign of the dividend, + for the given dividend for each element of the vector. + + The scalar numerator to use. + A vector to store the results in. + + + + Returns the value of the absolute minimum element. + + The value of the absolute minimum element. + + + + Returns the index of the absolute minimum element. + + The index of absolute minimum element. + + + + Returns the value of the absolute maximum element. + + The value of the absolute maximum element. + + + + Returns the index of the absolute maximum element. + + The index of absolute maximum element. + + + + Computes the sum of the vector's elements. + + The sum of the vector's elements. + + + + Calculates the L1 norm of the vector, also known as Manhattan norm. + + The sum of the absolute values. + + + + Calculates the L2 norm of the vector, also known as Euclidean norm. + + The square root of the sum of the squared values. + + + + Calculates the infinity norm of the vector. + + The maximum absolute value. + + + + Computes the p-Norm. + + + The p value. + + + Scalar ret = ( ∑|At(i)|^p )^(1/p) + + + + + Returns the index of the maximum element. + + The index of maximum element. + + + + Returns the index of the minimum element. + + The index of minimum element. + + + + Normalizes this vector to a unit vector with respect to the p-norm. + + + The p value. + + + This vector normalized to a unit vector with respect to the p-norm. + + + + + Generic linear algebra type builder, for situations where a matrix or vector + must be created in a generic way. Usage of generic builders should not be + required in normal user code. + + + + + Gets the value of 0.0 for type T. + + + + + Gets the value of 1.0 for type T. + + + + + Create a new matrix straight from an initialized matrix storage instance. + If you have an instance of a discrete storage type instead, use their direct methods instead. + + + + + Create a new matrix with the same kind of the provided example. + + + + + Create a new matrix with the same kind and dimensions of the provided example. + + + + + Create a new matrix with the same kind of the provided example. + + + + + Create a new matrix with a type that can represent and is closest to both provided samples. + + + + + Create a new matrix with a type that can represent and is closest to both provided samples and the dimensions of example. + + + + + Create a new dense matrix with values sampled from the provided random distribution. + + + + + Create a new dense matrix with values sampled from the standard distribution with a system random source. + + + + + Create a new dense matrix with values sampled from the standard distribution with a system random source. + + + + + Create a new positive definite dense matrix where each value is the product + of two samples from the provided random distribution. + + + + + Create a new positive definite dense matrix where each value is the product + of two samples from the standard distribution. + + + + + Create a new positive definite dense matrix where each value is the product + of two samples from the provided random distribution. + + + + + Create a new dense matrix straight from an initialized matrix storage instance. + The storage is used directly without copying. + Intended for advanced scenarios where you're working directly with + storage for performance or interop reasons. + + + + + Create a new dense matrix with the given number of rows and columns. + All cells of the matrix will be initialized to zero. + + + + + Create a new dense matrix with the given number of rows and columns directly binding to a raw array. + The array is assumed to be in column-major order (column by column) and is used directly without copying. + Very efficient, but changes to the array and the matrix will affect each other. + + + + + + Create a new dense matrix and initialize each value to the same provided value. + + + + + Create a new dense matrix and initialize each value using the provided init function. + + + + + Create a new diagonal dense matrix and initialize each diagonal value to the same provided value. + + + + + Create a new diagonal dense matrix and initialize each diagonal value to the same provided value. + + + + + Create a new diagonal dense matrix and initialize each diagonal value using the provided init function. + + + + + Create a new diagonal dense identity matrix with a one-diagonal. + + + + + Create a new diagonal dense identity matrix with a one-diagonal. + + + + + Create a new dense matrix as a copy of the given other matrix. + This new matrix will be independent from the other matrix. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given two-dimensional array. + This new matrix will be independent from the provided array. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given enumerable. + The enumerable is assumed to be in column-major order (column by column). + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given enumerable of enumerable columns. + Each enumerable in the master enumerable specifies a column. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given enumerable of enumerable columns. + Each enumerable in the master enumerable specifies a column. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix of T as a copy of the given column arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix of T as a copy of the given column arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given column vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given column vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given enumerable. + The enumerable is assumed to be in row-major order (row by row). + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given enumerable of enumerable rows. + Each enumerable in the master enumerable specifies a row. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given enumerable of enumerable rows. + Each enumerable in the master enumerable specifies a row. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix of T as a copy of the given row arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix of T as a copy of the given row arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given row vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given row vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix with the diagonal as a copy of the given vector. + This new matrix will be independent from the vector. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix with the diagonal as a copy of the given vector. + This new matrix will be independent from the vector. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix with the diagonal as a copy of the given array. + This new matrix will be independent from the array. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix with the diagonal as a copy of the given array. + This new matrix will be independent from the array. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix from a 2D array of existing matrices. + The matrices in the array are not required to be dense already. + If the matrices do not align properly, they are placed on the top left + corner of their cell with the remaining fields left zero. + + + + + Create a new sparse matrix straight from an initialized matrix storage instance. + The storage is used directly without copying. + Intended for advanced scenarios where you're working directly with + storage for performance or interop reasons. + + The SparseCompressedRowMatrixStorage + + + + Create a sparse matrix of T with the given number of rows and columns. + + The number of rows. + The number of columns. + + + + Create a new sparse matrix and initialize each value to the same provided value. + + + + + Create a new sparse matrix and initialize each value using the provided init function. + + + + + Create a new diagonal sparse matrix and initialize each diagonal value to the same provided value. + + + + + Create a new diagonal sparse matrix and initialize each diagonal value to the same provided value. + + + + + Create a new diagonal sparse matrix and initialize each diagonal value using the provided init function. + + + + + Create a new diagonal dense identity matrix with a one-diagonal. + + + + + Create a new diagonal dense identity matrix with a one-diagonal. + + + + + Create a new sparse matrix as a copy of the given other matrix. + This new matrix will be independent from the other matrix. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given two-dimensional array. + This new matrix will be independent from the provided array. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given enumerable. + The enumerable is assumed to be in row-major order (row by row). + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the vector. + + + + + + Create a new sparse matrix with the given number of rows and columns as a copy of the given array. + The array is assumed to be in column-major order (column by column). + This new matrix will be independent from the provided array. + A new memory block will be allocated for storing the matrix. + + + + + + Create a new sparse matrix as a copy of the given enumerable of enumerable columns. + Each enumerable in the master enumerable specifies a column. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given enumerable of enumerable columns. + Each enumerable in the master enumerable specifies a column. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given column arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given column arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given column vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given column vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given enumerable of enumerable rows. + Each enumerable in the master enumerable specifies a row. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given enumerable of enumerable rows. + Each enumerable in the master enumerable specifies a row. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given row arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given row arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given row vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given row vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix with the diagonal as a copy of the given vector. + This new matrix will be independent from the vector. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix with the diagonal as a copy of the given vector. + This new matrix will be independent from the vector. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix with the diagonal as a copy of the given array. + This new matrix will be independent from the array. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix with the diagonal as a copy of the given array. + This new matrix will be independent from the array. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix from a 2D array of existing matrices. + The matrices in the array are not required to be sparse already. + If the matrices do not align properly, they are placed on the top left + corner of their cell with the remaining fields left zero. + + + + + Create a new sparse matrix from a coordinate format. + This new matrix will be independent from the given arrays. + A new memory block will be allocated for storing the matrix. + + The number of rows. + The number of columns. + The number of stored values including explicit zeros. + The row index array of the coordinate format. + The column index array of the coordinate format. + The data array of the coordinate format. + The sparse matrix from the coordinate format. + Duplicate entries will be summed together and explicit zeros will be not intentionally removed. + + + + Create a new sparse matrix from a compressed sparse row format. + This new matrix will be independent from the given arrays. + A new memory block will be allocated for storing the matrix. + + The number of rows. + The number of columns. + The number of stored values including explicit zeros. + The row pointer array of the compressed sparse row format. + The column index array of the compressed sparse row format. + The data array of the compressed sparse row format. + The sparse matrix from the compressed sparse row format. + Duplicate entries will be summed together and explicit zeros will be not intentionally removed. + + + + Create a new sparse matrix from a compressed sparse column format. + This new matrix will be independent from the given arrays. + A new memory block will be allocated for storing the matrix. + + The number of rows. + The number of columns. + The number of stored values including explicit zeros. + The row index array of the compressed sparse column format. + The column pointer array of the compressed sparse column format. + The data array of the compressed sparse column format. + The sparse matrix from the compressed sparse column format. + Duplicate entries will be summed together and explicit zeros will be not intentionally removed. + + + + Create a new diagonal matrix straight from an initialized matrix storage instance. + The storage is used directly without copying. + Intended for advanced scenarios where you're working directly with + storage for performance or interop reasons. + + + + + Create a new diagonal matrix with the given number of rows and columns. + All cells of the matrix will be initialized to zero. + + + + + Create a new diagonal matrix with the given number of rows and columns directly binding to a raw array. + The array is assumed to represent the diagonal values and is used directly without copying. + Very efficient, but changes to the array and the matrix will affect each other. + + + + + Create a new square diagonal matrix directly binding to a raw array. + The array is assumed to represent the diagonal values and is used directly without copying. + Very efficient, but changes to the array and the matrix will affect each other. + + + + + Create a new diagonal matrix and initialize each diagonal value to the same provided value. + + + + + Create a new diagonal matrix and initialize each diagonal value using the provided init function. + + + + + Create a new diagonal identity matrix with a one-diagonal. + + + + + Create a new diagonal identity matrix with a one-diagonal. + + + + + Create a new diagonal matrix with the diagonal as a copy of the given vector. + This new matrix will be independent from the vector. + A new memory block will be allocated for storing the matrix. + + + + + Create a new diagonal matrix with the diagonal as a copy of the given vector. + This new matrix will be independent from the vector. + A new memory block will be allocated for storing the matrix. + + + + + Create a new diagonal matrix with the diagonal as a copy of the given array. + This new matrix will be independent from the array. + A new memory block will be allocated for storing the matrix. + + + + + Create a new diagonal matrix with the diagonal as a copy of the given array. + This new matrix will be independent from the array. + A new memory block will be allocated for storing the matrix. + + + + + Generic linear algebra type builder, for situations where a matrix or vector + must be created in a generic way. Usage of generic builders should not be + required in normal user code. + + + + + Gets the value of 0.0 for type T. + + + + + Gets the value of 1.0 for type T. + + + + + Create a new vector straight from an initialized matrix storage instance. + If you have an instance of a discrete storage type instead, use their direct methods instead. + + + + + Create a new vector with the same kind of the provided example. + + + + + Create a new vector with the same kind and dimension of the provided example. + + + + + Create a new vector with the same kind of the provided example. + + + + + Create a new vector with a type that can represent and is closest to both provided samples. + + + + + Create a new vector with a type that can represent and is closest to both provided samples and the dimensions of example. + + + + + Create a new vector with a type that can represent and is closest to both provided samples. + + + + + Create a new dense vector with values sampled from the provided random distribution. + + + + + Create a new dense vector with values sampled from the standard distribution with a system random source. + + + + + Create a new dense vector with values sampled from the standard distribution with a system random source. + + + + + Create a new dense vector straight from an initialized vector storage instance. + The storage is used directly without copying. + Intended for advanced scenarios where you're working directly with + storage for performance or interop reasons. + + + + + Create a dense vector of T with the given size. + + The size of the vector. + + + + Create a dense vector of T that is directly bound to the specified array. + + + + + Create a new dense vector and initialize each value using the provided value. + + + + + Create a new dense vector and initialize each value using the provided init function. + + + + + Create a new dense vector as a copy of the given other vector. + This new vector will be independent from the other vector. + A new memory block will be allocated for storing the vector. + + + + + Create a new dense vector as a copy of the given array. + This new vector will be independent from the array. + A new memory block will be allocated for storing the vector. + + + + + Create a new dense vector as a copy of the given enumerable. + This new vector will be independent from the enumerable. + A new memory block will be allocated for storing the vector. + + + + + Create a new dense vector as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new vector will be independent from the enumerable. + A new memory block will be allocated for storing the vector. + + + + + Create a new dense vector as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new vector will be independent from the enumerable. + A new memory block will be allocated for storing the vector. + + + + + Create a new sparse vector straight from an initialized vector storage instance. + The storage is used directly without copying. + Intended for advanced scenarios where you're working directly with + storage for performance or interop reasons. + + + + + Create a sparse vector of T with the given size. + + The size of the vector. + + + + Create a new sparse vector and initialize each value using the provided value. + + + + + Create a new sparse vector and initialize each value using the provided init function. + + + + + Create a new sparse vector as a copy of the given other vector. + This new vector will be independent from the other vector. + A new memory block will be allocated for storing the vector. + + + + + Create a new sparse vector as a copy of the given array. + This new vector will be independent from the array. + A new memory block will be allocated for storing the vector. + + + + + Create a new sparse vector as a copy of the given enumerable. + This new vector will be independent from the enumerable. + A new memory block will be allocated for storing the vector. + + + + + Create a new sparse vector as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new vector will be independent from the enumerable. + A new memory block will be allocated for storing the vector. + + + + + Create a new sparse vector as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new vector will be independent from the enumerable. + A new memory block will be allocated for storing the vector. + + + + + Create a new matrix straight from an initialized matrix storage instance. + If you have an instance of a discrete storage type instead, use their direct methods instead. + + + + + Create a new matrix with the same kind of the provided example. + + + + + Create a new matrix with the same kind and dimensions of the provided example. + + + + + Create a new matrix with the same kind of the provided example. + + + + + Create a new matrix with a type that can represent and is closest to both provided samples. + + + + + Create a new matrix with a type that can represent and is closest to both provided samples and the dimensions of example. + + + + + Create a new dense matrix with values sampled from the provided random distribution. + + + + + Create a new dense matrix with values sampled from the standard distribution with a system random source. + + + + + Create a new dense matrix with values sampled from the standard distribution with a system random source. + + + + + Create a new positive definite dense matrix where each value is the product + of two samples from the provided random distribution. + + + + + Create a new positive definite dense matrix where each value is the product + of two samples from the standard distribution. + + + + + Create a new positive definite dense matrix where each value is the product + of two samples from the provided random distribution. + + + + + Create a new dense matrix straight from an initialized matrix storage instance. + The storage is used directly without copying. + Intended for advanced scenarios where you're working directly with + storage for performance or interop reasons. + + + + + Create a new dense matrix with the given number of rows and columns. + All cells of the matrix will be initialized to zero. + + + + + Create a new dense matrix with the given number of rows and columns directly binding to a raw array. + The array is assumed to be in column-major order (column by column) and is used directly without copying. + Very efficient, but changes to the array and the matrix will affect each other. + + + + + + Create a new dense matrix and initialize each value to the same provided value. + + + + + Create a new dense matrix and initialize each value using the provided init function. + + + + + Create a new diagonal dense matrix and initialize each diagonal value to the same provided value. + + + + + Create a new diagonal dense matrix and initialize each diagonal value to the same provided value. + + + + + Create a new diagonal dense matrix and initialize each diagonal value using the provided init function. + + + + + Create a new diagonal dense identity matrix with a one-diagonal. + + + + + Create a new diagonal dense identity matrix with a one-diagonal. + + + + + Create a new dense matrix as a copy of the given other matrix. + This new matrix will be independent from the other matrix. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given two-dimensional array. + This new matrix will be independent from the provided array. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given enumerable. + The enumerable is assumed to be in column-major order (column by column). + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given enumerable of enumerable columns. + Each enumerable in the master enumerable specifies a column. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given enumerable of enumerable columns. + Each enumerable in the master enumerable specifies a column. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix of T as a copy of the given column arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix of T as a copy of the given column arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given column vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given column vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given enumerable of enumerable rows. + Each enumerable in the master enumerable specifies a row. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given enumerable of enumerable rows. + Each enumerable in the master enumerable specifies a row. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix of T as a copy of the given row arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix of T as a copy of the given row arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given row vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix as a copy of the given row vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix with the diagonal as a copy of the given vector. + This new matrix will be independent from the vector. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix with the diagonal as a copy of the given vector. + This new matrix will be independent from the vector. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix with the diagonal as a copy of the given array. + This new matrix will be independent from the array. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix with the diagonal as a copy of the given array. + This new matrix will be independent from the array. + A new memory block will be allocated for storing the matrix. + + + + + Create a new dense matrix from a 2D array of existing matrices. + The matrices in the array are not required to be dense already. + If the matrices do not align properly, they are placed on the top left + corner of their cell with the remaining fields left zero. + + + + + Create a new sparse matrix straight from an initialized matrix storage instance. + The storage is used directly without copying. + Intended for advanced scenarios where you're working directly with + storage for performance or interop reasons. + + + + + Create a sparse matrix of T with the given number of rows and columns. + + The number of rows. + The number of columns. + + + + Create a new sparse matrix and initialize each value to the same provided value. + + + + + Create a new sparse matrix and initialize each value using the provided init function. + + + + + Create a new diagonal sparse matrix and initialize each diagonal value to the same provided value. + + + + + Create a new diagonal sparse matrix and initialize each diagonal value to the same provided value. + + + + + Create a new diagonal sparse matrix and initialize each diagonal value using the provided init function. + + + + + Create a new diagonal dense identity matrix with a one-diagonal. + + + + + Create a new diagonal dense identity matrix with a one-diagonal. + + + + + Create a new sparse matrix as a copy of the given other matrix. + This new matrix will be independent from the other matrix. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given two-dimensional array. + This new matrix will be independent from the provided array. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given enumerable. + The enumerable is assumed to be in row-major order (row by row). + This new matrix will be independent from the enumerable. + A new memory block will be allocated for storing the vector. + + + + + + Create a new sparse matrix with the given number of rows and columns as a copy of the given array. + The array is assumed to be in column-major order (column by column). + This new matrix will be independent from the provided array. + A new memory block will be allocated for storing the matrix. + + + + + + Create a new sparse matrix as a copy of the given enumerable of enumerable columns. + Each enumerable in the master enumerable specifies a column. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given enumerable of enumerable columns. + Each enumerable in the master enumerable specifies a column. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given column arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given column arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given column vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given column vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given enumerable of enumerable rows. + Each enumerable in the master enumerable specifies a row. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given enumerable of enumerable rows. + Each enumerable in the master enumerable specifies a row. + This new matrix will be independent from the enumerables. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given row arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given row arrays. + This new matrix will be independent from the arrays. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given row vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix as a copy of the given row vectors. + This new matrix will be independent from the vectors. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix with the diagonal as a copy of the given vector. + This new matrix will be independent from the vector. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix with the diagonal as a copy of the given vector. + This new matrix will be independent from the vector. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix with the diagonal as a copy of the given array. + This new matrix will be independent from the array. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix with the diagonal as a copy of the given array. + This new matrix will be independent from the array. + A new memory block will be allocated for storing the matrix. + + + + + Create a new sparse matrix from a 2D array of existing matrices. + The matrices in the array are not required to be sparse already. + If the matrices do not align properly, they are placed on the top left + corner of their cell with the remaining fields left zero. + + + + + Create a new sparse matrix from a coordinate format. + This new matrix will be independent from the given arrays. + A new memory block will be allocated for storing the matrix. + + The number of rows. + The number of columns. + The number of stored values including explicit zeros. + The row index array of the coordinate format. + The column index array of the coordinate format. + The data array of the coordinate format. + The sparse matrix from the coordinate format. + Duplicate entries will be summed together and explicit zeros will be not intentionally removed. + + + + Create a new sparse matrix from a compressed sparse row format. + This new matrix will be independent from the given arrays. + A new memory block will be allocated for storing the matrix. + + The number of rows. + The number of columns. + The number of stored values including explicit zeros. + The row pointer array of the compressed sparse row format. + The column index array of the compressed sparse row format. + The data array of the compressed sparse row format. + The sparse matrix from the compressed sparse row format. + Duplicate entries will be summed together and explicit zeros will be not intentionally removed. + + + + Create a new sparse matrix from a compressed sparse column format. + This new matrix will be independent from the given arrays. + A new memory block will be allocated for storing the matrix. + + The number of rows. + The number of columns. + The number of stored values including explicit zeros. + The row index array of the compressed sparse column format. + The column pointer array of the compressed sparse column format. + The data array of the compressed sparse column format. + The sparse matrix from the compressed sparse column format. + Duplicate entries will be summed together and explicit zeros will be not intentionally removed. + + + + Create a new diagonal matrix straight from an initialized matrix storage instance. + The storage is used directly without copying. + Intended for advanced scenarios where you're working directly with + storage for performance or interop reasons. + + + + + Create a new diagonal matrix with the given number of rows and columns. + All cells of the matrix will be initialized to zero. + + + + + Create a new diagonal matrix with the given number of rows and columns directly binding to a raw array. + The array is assumed to represent the diagonal values and is used directly without copying. + Very efficient, but changes to the array and the matrix will affect each other. + + + + + Create a new square diagonal matrix directly binding to a raw array. + The array is assumed to represent the diagonal values and is used directly without copying. + Very efficient, but changes to the array and the matrix will affect each other. + + + + + Create a new diagonal matrix and initialize each diagonal value to the same provided value. + + + + + Create a new diagonal matrix and initialize each diagonal value using the provided init function. + + + + + Create a new diagonal identity matrix with a one-diagonal. + + + + + Create a new diagonal identity matrix with a one-diagonal. + + + + + Create a new diagonal matrix with the diagonal as a copy of the given vector. + This new matrix will be independent from the vector. + A new memory block will be allocated for storing the matrix. + + + + + Create a new diagonal matrix with the diagonal as a copy of the given vector. + This new matrix will be independent from the vector. + A new memory block will be allocated for storing the matrix. + + + + + Create a new diagonal matrix with the diagonal as a copy of the given array. + This new matrix will be independent from the array. + A new memory block will be allocated for storing the matrix. + + + + + Create a new diagonal matrix with the diagonal as a copy of the given array. + This new matrix will be independent from the array. + A new memory block will be allocated for storing the matrix. + + + + + Create a new vector straight from an initialized matrix storage instance. + If you have an instance of a discrete storage type instead, use their direct methods instead. + + + + + Create a new vector with the same kind of the provided example. + + + + + Create a new vector with the same kind and dimension of the provided example. + + + + + Create a new vector with the same kind of the provided example. + + + + + Create a new vector with a type that can represent and is closest to both provided samples. + + + + + Create a new vector with a type that can represent and is closest to both provided samples and the dimensions of example. + + + + + Create a new vector with a type that can represent and is closest to both provided samples. + + + + + Create a new dense vector with values sampled from the provided random distribution. + + + + + Create a new dense vector with values sampled from the standard distribution with a system random source. + + + + + Create a new dense vector with values sampled from the standard distribution with a system random source. + + + + + Create a new dense vector straight from an initialized vector storage instance. + The storage is used directly without copying. + Intended for advanced scenarios where you're working directly with + storage for performance or interop reasons. + + + + + Create a dense vector of T with the given size. + + The size of the vector. + + + + Create a dense vector of T that is directly bound to the specified array. + + + + + Create a new dense vector and initialize each value using the provided value. + + + + + Create a new dense vector and initialize each value using the provided init function. + + + + + Create a new dense vector as a copy of the given other vector. + This new vector will be independent from the other vector. + A new memory block will be allocated for storing the vector. + + + + + Create a new dense vector as a copy of the given array. + This new vector will be independent from the array. + A new memory block will be allocated for storing the vector. + + + + + Create a new dense vector as a copy of the given enumerable. + This new vector will be independent from the enumerable. + A new memory block will be allocated for storing the vector. + + + + + Create a new dense vector as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new vector will be independent from the enumerable. + A new memory block will be allocated for storing the vector. + + + + + Create a new dense vector as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new vector will be independent from the enumerable. + A new memory block will be allocated for storing the vector. + + + + + Create a new sparse vector straight from an initialized vector storage instance. + The storage is used directly without copying. + Intended for advanced scenarios where you're working directly with + storage for performance or interop reasons. + + + + + Create a sparse vector of T with the given size. + + The size of the vector. + + + + Create a new sparse vector and initialize each value using the provided value. + + + + + Create a new sparse vector and initialize each value using the provided init function. + + + + + Create a new sparse vector as a copy of the given other vector. + This new vector will be independent from the other vector. + A new memory block will be allocated for storing the vector. + + + + + Create a new sparse vector as a copy of the given array. + This new vector will be independent from the array. + A new memory block will be allocated for storing the vector. + + + + + Create a new sparse vector as a copy of the given enumerable. + This new vector will be independent from the enumerable. + A new memory block will be allocated for storing the vector. + + + + + Create a new sparse vector as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new vector will be independent from the enumerable. + A new memory block will be allocated for storing the vector. + + + + + Create a new sparse vector as a copy of the given indexed enumerable. + Keys must be provided at most once, zero is assumed if a key is omitted. + This new vector will be independent from the enumerable. + A new memory block will be allocated for storing the vector. + + + + + A class which encapsulates the functionality of a Cholesky factorization. + For a symmetric, positive definite matrix A, the Cholesky factorization + is an lower triangular matrix L so that A = L*L'. + + + The computation of the Cholesky factorization is done at construction time. If the matrix is not symmetric + or positive definite, the constructor will throw an exception. + + Supported data types are double, single, , and . + + + + Gets the lower triangular form of the Cholesky matrix. + + + + + Gets the determinant of the matrix for which the Cholesky matrix was computed. + + + + + Gets the log determinant of the matrix for which the Cholesky matrix was computed. + + + + + Calculates the Cholesky factorization of the input matrix. + + The matrix to be factorized. + + + + Solves a system of linear equations, AX = B, with A Cholesky factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, AX = B, with A Cholesky factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A Cholesky factorized. + + The right hand side vector, b. + The left hand side , x. + + + + Solves a system of linear equations, Ax = b, with A Cholesky factorized. + + The right hand side vector, b. + The left hand side , x. + + + + Eigenvalues and eigenvectors of a real matrix. + + + If A is symmetric, then A = V*D*V' where the eigenvalue matrix D is + diagonal and the eigenvector matrix V is orthogonal. + I.e. A = V*D*V' and V*VT=I. + If A is not symmetric, then the eigenvalue matrix D is block diagonal + with the real eigenvalues in 1-by-1 blocks and any complex eigenvalues, + lambda + i*mu, in 2-by-2 blocks, [lambda, mu; -mu, lambda]. The + columns of V represent the eigenvectors in the sense that A*V = V*D, + i.e. A.Multiply(V) equals V.Multiply(D). The matrix V may be badly + conditioned, or even singular, so the validity of the equation + A = V*D*Inverse(V) depends upon V.Condition(). + + Supported data types are double, single, , and . + + + + Gets or sets a value indicating whether matrix is symmetric or not + + + + + Gets the absolute value of determinant of the square matrix for which the EVD was computed. + + + + + Gets the effective numerical matrix rank. + + The number of non-negligible singular values. + + + + Gets a value indicating whether the matrix is full rank or not. + + true if the matrix is full rank; otherwise false. + + + + Gets or sets the eigen values (λ) of matrix in ascending value. + + + + + Gets or sets eigenvectors. + + + + + Gets or sets the block diagonal eigenvalue matrix. + + + + + Solves a system of linear equations, AX = B, with A EVD factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, AX = B, with A EVD factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A EVD factorized. + + The right hand side vector, b. + The left hand side , x. + + + + Solves a system of linear equations, Ax = b, with A EVD factorized. + + The right hand side vector, b. + The left hand side , x. + + + + A class which encapsulates the functionality of the QR decomposition Modified Gram-Schmidt Orthogonalization. + Any real square matrix A may be decomposed as A = QR where Q is an orthogonal mxn matrix and R is an nxn upper triangular matrix. + + + The computation of the QR decomposition is done at construction time by modified Gram-Schmidt Orthogonalization. + + Supported data types are double, single, , and . + + + + Classes that solves a system of linear equations, AX = B. + + Supported data types are double, single, , and . + + + + Solves a system of linear equations, AX = B. + + The right hand side Matrix, B. + The left hand side Matrix, X. + + + + Solves a system of linear equations, AX = B. + + The right hand side Matrix, B. + The left hand side Matrix, X. + + + + Solves a system of linear equations, Ax = b + + The right hand side vector, b. + The left hand side Vector, x. + + + + Solves a system of linear equations, Ax = b. + + The right hand side vector, b. + The left hand side Matrix>, x. + + + + A class which encapsulates the functionality of an LU factorization. + For a matrix A, the LU factorization is a pair of lower triangular matrix L and + upper triangular matrix U so that A = L*U. + In the Math.NET implementation we also store a set of pivot elements for increased + numerical stability. The pivot elements encode a permutation matrix P such that P*A = L*U. + + + The computation of the LU factorization is done at construction time. + + Supported data types are double, single, , and . + + + + Gets the lower triangular factor. + + + + + Gets the upper triangular factor. + + + + + Gets the permutation applied to LU factorization. + + + + + Gets the determinant of the matrix for which the LU factorization was computed. + + + + + Solves a system of linear equations, AX = B, with A LU factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, AX = B, with A LU factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A LU factorized. + + The right hand side vector, b. + The left hand side , x. + + + + Solves a system of linear equations, Ax = b, with A LU factorized. + + The right hand side vector, b. + The left hand side , x. + + + + Returns the inverse of this matrix. The inverse is calculated using LU decomposition. + + The inverse of this matrix. + + + + The type of QR factorization go perform. + + + + + Compute the full QR factorization of a matrix. + + + + + Compute the thin QR factorization of a matrix. + + + + + A class which encapsulates the functionality of the QR decomposition. + Any real square matrix A (m x n) may be decomposed as A = QR where Q is an orthogonal matrix + (its columns are orthogonal unit vectors meaning QTQ = I) and R is an upper triangular matrix + (also called right triangular matrix). + + + The computation of the QR decomposition is done at construction time by Householder transformation. + If a factorization is performed, the resulting Q matrix is an m x m matrix + and the R matrix is an m x n matrix. If a factorization is performed, the + resulting Q matrix is an m x n matrix and the R matrix is an n x n matrix. + + Supported data types are double, single, , and . + + + + Gets or sets orthogonal Q matrix + + + + + Gets the upper triangular factor R. + + + + + Gets the absolute determinant value of the matrix for which the QR matrix was computed. + + + + + Gets a value indicating whether the matrix is full rank or not. + + true if the matrix is full rank; otherwise false. + + + + Solves a system of linear equations, AX = B, with A QR factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, AX = B, with A QR factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A QR factorized. + + The right hand side vector, b. + The left hand side , x. + + + + Solves a system of linear equations, Ax = b, with A QR factorized. + + The right hand side vector, b. + The left hand side , x. + + + + A class which encapsulates the functionality of the singular value decomposition (SVD). + Suppose M is an m-by-n matrix whose entries are real numbers. + Then there exists a factorization of the form M = UΣVT where: + - U is an m-by-m unitary matrix; + - Σ is m-by-n diagonal matrix with nonnegative real numbers on the diagonal; + - VT denotes transpose of V, an n-by-n unitary matrix; + Such a factorization is called a singular-value decomposition of M. A common convention is to order the diagonal + entries Σ(i,i) in descending order. In this case, the diagonal matrix Σ is uniquely determined + by M (though the matrices U and V are not). The diagonal entries of Σ are known as the singular values of M. + + + The computation of the singular value decomposition is done at construction time. + + Supported data types are double, single, , and . + + + Indicating whether U and VT matrices have been computed during SVD factorization. + + + + Gets the singular values (Σ) of matrix in ascending value. + + + + + Gets the left singular vectors (U - m-by-m unitary matrix) + + + + + Gets the transpose right singular vectors (transpose of V, an n-by-n unitary matrix) + + + + + Returns the singular values as a diagonal . + + The singular values as a diagonal . + + + + Gets the effective numerical matrix rank. + + The number of non-negligible singular values. + + + + Gets the two norm of the . + + The 2-norm of the . + + + + Gets the condition number max(S) / min(S) + + The condition number. + + + + Gets the determinant of the square matrix for which the SVD was computed. + + + + + Solves a system of linear equations, AX = B, with A SVD factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, AX = B, with A SVD factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A SVD factorized. + + The right hand side vector, b. + The left hand side , x. + + + + Solves a system of linear equations, Ax = b, with A SVD factorized. + + The right hand side vector, b. + The left hand side , x. + + + + Defines the base class for Matrix classes. + + + Defines the base class for Matrix classes. + + Supported data types are double, single, , and . + + Defines the base class for Matrix classes. + + + Defines the base class for Matrix classes. + + + + + The value of 1.0. + + + + + The value of 0.0. + + + + + Negate each element of this matrix and place the results into the result matrix. + + The result of the negation. + + + + Complex conjugates each element of this matrix and place the results into the result matrix. + + The result of the conjugation. + + + + Add a scalar to each element of the matrix and stores the result in the result vector. + + The scalar to add. + The matrix to store the result of the addition. + + + + Adds another matrix to this matrix. + + The matrix to add to this matrix. + The matrix to store the result of the addition. + If the two matrices don't have the same dimensions. + + + + Subtracts a scalar from each element of the matrix and stores the result in the result matrix. + + The scalar to subtract. + The matrix to store the result of the subtraction. + + + + Subtracts each element of the matrix from a scalar and stores the result in the result matrix. + + The scalar to subtract from. + The matrix to store the result of the subtraction. + + + + Subtracts another matrix from this matrix. + + The matrix to subtract. + The matrix to store the result of the subtraction. + + + + Multiplies each element of the matrix by a scalar and places results into the result matrix. + + The scalar to multiply the matrix with. + The matrix to store the result of the multiplication. + + + + Multiplies this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + + + + Multiplies this matrix with another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies this matrix with the transpose of another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies this matrix with the conjugate transpose of another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies the transpose of this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + + + + Multiplies the conjugate transpose of this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + + + + Multiplies the transpose of this matrix with another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Multiplies the transpose of this matrix with another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + + + + Divides each element of the matrix by a scalar and places results into the result matrix. + + The scalar denominator to use. + The matrix to store the result of the division. + + + + Divides a scalar by each element of the matrix and stores the result in the result matrix. + + The scalar numerator to use. + The matrix to store the result of the division. + + + + Computes the canonical modulus, where the result has the sign of the divisor, + for the given divisor each element of the matrix. + + The scalar denominator to use. + Matrix to store the results in. + + + + Computes the canonical modulus, where the result has the sign of the divisor, + for the given dividend for each element of the matrix. + + The scalar numerator to use. + A vector to store the results in. + + + + Computes the remainder (% operator), where the result has the sign of the dividend, + for the given divisor each element of the matrix. + + The scalar denominator to use. + Matrix to store the results in. + + + + Computes the remainder (% operator), where the result has the sign of the dividend, + for the given dividend for each element of the matrix. + + The scalar numerator to use. + A vector to store the results in. + + + + Pointwise multiplies this matrix with another matrix and stores the result into the result matrix. + + The matrix to pointwise multiply with this one. + The matrix to store the result of the pointwise multiplication. + + + + Pointwise divide this matrix by another matrix and stores the result into the result matrix. + + The pointwise denominator matrix to use. + The matrix to store the result of the pointwise division. + + + + Pointwise raise this matrix to an exponent and store the result into the result matrix. + + The exponent to raise this matrix values to. + The matrix to store the result of the pointwise power. + + + + Pointwise raise this matrix to an exponent matrix and store the result into the result matrix. + + The exponent matrix to raise this matrix values to. + The matrix to store the result of the pointwise power. + + + + Pointwise canonical modulus, where the result has the sign of the divisor, + of this matrix with another matrix and stores the result into the result matrix. + + The pointwise denominator matrix to use + The result of the modulus. + + + + Pointwise remainder (% operator), where the result has the sign of the dividend, + of this matrix with another matrix and stores the result into the result matrix. + + The pointwise denominator matrix to use + The result of the modulus. + + + + Pointwise applies the exponential function to each value and stores the result into the result matrix. + + The matrix to store the result. + + + + Pointwise applies the natural logarithm function to each value and stores the result into the result matrix. + + The matrix to store the result. + + + + Adds a scalar to each element of the matrix. + + The scalar to add. + The result of the addition. + If the two matrices don't have the same dimensions. + + + + Adds a scalar to each element of the matrix and stores the result in the result matrix. + + The scalar to add. + The matrix to store the result of the addition. + If the two matrices don't have the same dimensions. + + + + Adds another matrix to this matrix. + + The matrix to add to this matrix. + The result of the addition. + If the two matrices don't have the same dimensions. + + + + Adds another matrix to this matrix. + + The matrix to add to this matrix. + The matrix to store the result of the addition. + If the two matrices don't have the same dimensions. + + + + Subtracts a scalar from each element of the matrix. + + The scalar to subtract. + A new matrix containing the subtraction of this matrix and the scalar. + + + + Subtracts a scalar from each element of the matrix and stores the result in the result matrix. + + The scalar to subtract. + The matrix to store the result of the subtraction. + If this matrix and are not the same size. + + + + Subtracts each element of the matrix from a scalar. + + The scalar to subtract from. + A new matrix containing the subtraction of the scalar and this matrix. + + + + Subtracts each element of the matrix from a scalar and stores the result in the result matrix. + + The scalar to subtract from. + The matrix to store the result of the subtraction. + If this matrix and are not the same size. + + + + Subtracts another matrix from this matrix. + + The matrix to subtract. + The result of the subtraction. + If the two matrices don't have the same dimensions. + + + + Subtracts another matrix from this matrix. + + The matrix to subtract. + The matrix to store the result of the subtraction. + If the two matrices don't have the same dimensions. + + + + Multiplies each element of this matrix with a scalar. + + The scalar to multiply with. + The result of the multiplication. + + + + Multiplies each element of the matrix by a scalar and places results into the result matrix. + + The scalar to multiply the matrix with. + The matrix to store the result of the multiplication. + If the result matrix's dimensions are not the same as this matrix. + + + + Divides each element of this matrix with a scalar. + + The scalar to divide with. + The result of the division. + + + + Divides each element of the matrix by a scalar and places results into the result matrix. + + The scalar to divide the matrix with. + The matrix to store the result of the division. + If the result matrix's dimensions are not the same as this matrix. + + + + Divides a scalar by each element of the matrix. + + The scalar to divide. + The result of the division. + + + + Divides a scalar by each element of the matrix and places results into the result matrix. + + The scalar to divide. + The matrix to store the result of the division. + If the result matrix's dimensions are not the same as this matrix. + + + + Multiplies this matrix by a vector and returns the result. + + The vector to multiply with. + The result of the multiplication. + If this.ColumnCount != rightSide.Count. + + + + Multiplies this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + If result.Count != this.RowCount. + If this.ColumnCount != .Count. + + + + Left multiply a matrix with a vector ( = vector * matrix ). + + The vector to multiply with. + The result of the multiplication. + If this.RowCount != .Count. + + + + Left multiply a matrix with a vector ( = vector * matrix ) and place the result in the result vector. + + The vector to multiply with. + The result of the multiplication. + If result.Count != this.ColumnCount. + If this.RowCount != .Count. + + + + Left multiply a matrix with a vector ( = vector * matrix ) and place the result in the result vector. + + The vector to multiply with. + The result of the multiplication. + + + + Multiplies this matrix with another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + If this.Columns != other.Rows. + If the result matrix's dimensions are not the this.Rows x other.Columns. + + + + Multiplies this matrix with another matrix and returns the result. + + The matrix to multiply with. + If this.Columns != other.Rows. + The result of the multiplication. + + + + Multiplies this matrix with transpose of another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + If this.Columns != other.ColumnCount. + If the result matrix's dimensions are not the this.RowCount x other.RowCount. + + + + Multiplies this matrix with transpose of another matrix and returns the result. + + The matrix to multiply with. + If this.Columns != other.ColumnCount. + The result of the multiplication. + + + + Multiplies the transpose of this matrix by a vector and returns the result. + + The vector to multiply with. + The result of the multiplication. + If this.RowCount != rightSide.Count. + + + + Multiplies the transpose of this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + If result.Count != this.ColumnCount. + If this.RowCount != .Count. + + + + Multiplies the transpose of this matrix with another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + If this.Rows != other.RowCount. + If the result matrix's dimensions are not the this.ColumnCount x other.ColumnCount. + + + + Multiplies the transpose of this matrix with another matrix and returns the result. + + The matrix to multiply with. + If this.Rows != other.RowCount. + The result of the multiplication. + + + + Multiplies this matrix with the conjugate transpose of another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + If this.Columns != other.ColumnCount. + If the result matrix's dimensions are not the this.RowCount x other.RowCount. + + + + Multiplies this matrix with the conjugate transpose of another matrix and returns the result. + + The matrix to multiply with. + If this.Columns != other.ColumnCount. + The result of the multiplication. + + + + Multiplies the conjugate transpose of this matrix by a vector and returns the result. + + The vector to multiply with. + The result of the multiplication. + If this.RowCount != rightSide.Count. + + + + Multiplies the conjugate transpose of this matrix with a vector and places the results into the result vector. + + The vector to multiply with. + The result of the multiplication. + If result.Count != this.ColumnCount. + If this.RowCount != .Count. + + + + Multiplies the conjugate transpose of this matrix with another matrix and places the results into the result matrix. + + The matrix to multiply with. + The result of the multiplication. + If this.Rows != other.RowCount. + If the result matrix's dimensions are not the this.ColumnCount x other.ColumnCount. + + + + Multiplies the conjugate transpose of this matrix with another matrix and returns the result. + + The matrix to multiply with. + If this.Rows != other.RowCount. + The result of the multiplication. + + + + Raises this square matrix to a positive integer exponent and places the results into the result matrix. + + The positive integer exponent to raise the matrix to. + The result of the power. + + + + Multiplies this square matrix with another matrix and returns the result. + + The positive integer exponent to raise the matrix to. + + + + Negate each element of this matrix. + + A matrix containing the negated values. + + + + Negate each element of this matrix and place the results into the result matrix. + + The result of the negation. + if the result matrix's dimensions are not the same as this matrix. + + + + Complex conjugate each element of this matrix. + + A matrix containing the conjugated values. + + + + Complex conjugate each element of this matrix and place the results into the result matrix. + + The result of the conjugation. + if the result matrix's dimensions are not the same as this matrix. + + + + Computes the canonical modulus, where the result has the sign of the divisor, + for each element of the matrix. + + The scalar denominator to use. + A matrix containing the results. + + + + Computes the canonical modulus, where the result has the sign of the divisor, + for each element of the matrix. + + The scalar denominator to use. + Matrix to store the results in. + + + + Computes the canonical modulus, where the result has the sign of the divisor, + for each element of the matrix. + + The scalar numerator to use. + A matrix containing the results. + + + + Computes the canonical modulus, where the result has the sign of the divisor, + for each element of the matrix. + + The scalar numerator to use. + Matrix to store the results in. + + + + Computes the remainder (matrix % divisor), where the result has the sign of the dividend, + for each element of the matrix. + + The scalar denominator to use. + A matrix containing the results. + + + + Computes the remainder (matrix % divisor), where the result has the sign of the dividend, + for each element of the matrix. + + The scalar denominator to use. + Matrix to store the results in. + + + + Computes the remainder (dividend % matrix), where the result has the sign of the dividend, + for each element of the matrix. + + The scalar numerator to use. + A matrix containing the results. + + + + Computes the remainder (dividend % matrix), where the result has the sign of the dividend, + for each element of the matrix. + + The scalar numerator to use. + Matrix to store the results in. + + + + Pointwise multiplies this matrix with another matrix. + + The matrix to pointwise multiply with this one. + If this matrix and are not the same size. + A new matrix that is the pointwise multiplication of this matrix and . + + + + Pointwise multiplies this matrix with another matrix and stores the result into the result matrix. + + The matrix to pointwise multiply with this one. + The matrix to store the result of the pointwise multiplication. + If this matrix and are not the same size. + If this matrix and are not the same size. + + + + Pointwise divide this matrix by another matrix. + + The pointwise denominator matrix to use. + If this matrix and are not the same size. + A new matrix that is the pointwise division of this matrix and . + + + + Pointwise divide this matrix by another matrix and stores the result into the result matrix. + + The pointwise denominator matrix to use. + The matrix to store the result of the pointwise division. + If this matrix and are not the same size. + If this matrix and are not the same size. + + + + Pointwise raise this matrix to an exponent and store the result into the result matrix. + + The exponent to raise this matrix values to. + + + + Pointwise raise this matrix to an exponent. + + The exponent to raise this matrix values to. + The matrix to store the result into. + If this matrix and are not the same size. + + + + Pointwise raise this matrix to an exponent and store the result into the result matrix. + + The exponent to raise this matrix values to. + + + + Pointwise raise this matrix to an exponent. + + The exponent to raise this matrix values to. + The matrix to store the result into. + If this matrix and are not the same size. + + + + Pointwise canonical modulus, where the result has the sign of the divisor, + of this matrix by another matrix. + + The pointwise denominator matrix to use. + If this matrix and are not the same size. + + + + Pointwise canonical modulus, where the result has the sign of the divisor, + of this matrix by another matrix and stores the result into the result matrix. + + The pointwise denominator matrix to use. + The matrix to store the result of the pointwise modulus. + If this matrix and are not the same size. + If this matrix and are not the same size. + + + + Pointwise remainder (% operator), where the result has the sign of the dividend, + of this matrix by another matrix. + + The pointwise denominator matrix to use. + If this matrix and are not the same size. + + + + Pointwise remainder (% operator), where the result has the sign of the dividend, + of this matrix by another matrix and stores the result into the result matrix. + + The pointwise denominator matrix to use. + The matrix to store the result of the pointwise remainder. + If this matrix and are not the same size. + If this matrix and are not the same size. + + + + Helper function to apply a unary function to a matrix. The function + f modifies the matrix given to it in place. Before its + called, a copy of the 'this' matrix is first created, then passed to + f. The copy is then returned as the result + + Function which takes a matrix, modifies it in place and returns void + New instance of matrix which is the result + + + + Helper function to apply a unary function which modifies a matrix + in place. + + Function which takes a matrix, modifies it in place and returns void + The matrix to be passed to f and where the result is to be stored + If this vector and are not the same size. + + + + Helper function to apply a binary function which takes two matrices + and modifies the latter in place. A copy of the "this" matrix is + first made and then passed to f together with the other matrix. The + copy is then returned as the result + + Function which takes two matrices, modifies the second in place and returns void + The other matrix to be passed to the function as argument. It is not modified + The resulting matrix + If this matrix and are not the same dimension. + + + + Helper function to apply a binary function which takes two matrices + and modifies the second one in place + + Function which takes two matrices, modifies the second in place and returns void + The other matrix to be passed to the function as argument. It is not modified + The matrix to store the result. + The resulting matrix + If this matrix and are not the same dimension. + + + + Pointwise applies the exponent function to each value. + + + + + Pointwise applies the exponent function to each value. + + The matrix to store the result. + If this matrix and are not the same size. + + + + Pointwise applies the natural logarithm function to each value. + + + + + Pointwise applies the natural logarithm function to each value. + + The matrix to store the result. + If this matrix and are not the same size. + + + + Pointwise applies the abs function to each value + + + + + Pointwise applies the abs function to each value + + The vector to store the result + + + + Pointwise applies the acos function to each value + + + + + Pointwise applies the acos function to each value + + The vector to store the result + + + + Pointwise applies the asin function to each value + + + + + Pointwise applies the asin function to each value + + The vector to store the result + + + + Pointwise applies the atan function to each value + + + + + Pointwise applies the atan function to each value + + The vector to store the result + + + + Pointwise applies the atan2 function to each value of the current + matrix and a given other matrix being the 'x' of atan2 and the + 'this' matrix being the 'y' + + + + + + + Pointwise applies the atan2 function to each value of the current + matrix and a given other matrix being the 'x' of atan2 and the + 'this' matrix being the 'y' + + The other matrix 'y' + The matrix with the result and 'x' + + + + + Pointwise applies the ceiling function to each value + + + + + Pointwise applies the ceiling function to each value + + The vector to store the result + + + + Pointwise applies the cos function to each value + + + + + Pointwise applies the cos function to each value + + The vector to store the result + + + + Pointwise applies the cosh function to each value + + + + + Pointwise applies the cosh function to each value + + The vector to store the result + + + + Pointwise applies the floor function to each value + + + + + Pointwise applies the floor function to each value + + The vector to store the result + + + + Pointwise applies the log10 function to each value + + + + + Pointwise applies the log10 function to each value + + The vector to store the result + + + + Pointwise applies the round function to each value + + + + + Pointwise applies the round function to each value + + The vector to store the result + + + + Pointwise applies the sign function to each value + + + + + Pointwise applies the sign function to each value + + The vector to store the result + + + + Pointwise applies the sin function to each value + + + + + Pointwise applies the sin function to each value + + The vector to store the result + + + + Pointwise applies the sinh function to each value + + + + + Pointwise applies the sinh function to each value + + The vector to store the result + + + + Pointwise applies the sqrt function to each value + + + + + Pointwise applies the sqrt function to each value + + The vector to store the result + + + + Pointwise applies the tan function to each value + + + + + Pointwise applies the tan function to each value + + The vector to store the result + + + + Pointwise applies the tanh function to each value + + + + + Pointwise applies the tanh function to each value + + The vector to store the result + + + + Computes the trace of this matrix. + + The trace of this matrix + If the matrix is not square + + + + Calculates the rank of the matrix. + + effective numerical rank, obtained from SVD + + + + Calculates the nullity of the matrix. + + effective numerical nullity, obtained from SVD + + + Calculates the condition number of this matrix. + The condition number of the matrix. + The condition number is calculated using singular value decomposition. + + + Computes the determinant of this matrix. + The determinant of this matrix. + + + + Computes an orthonormal basis for the null space of this matrix, + also known as the kernel of the corresponding matrix transformation. + + + + + Computes an orthonormal basis for the column space of this matrix, + also known as the range or image of the corresponding matrix transformation. + + + + Computes the inverse of this matrix. + The inverse of this matrix. + + + Computes the Moore-Penrose Pseudo-Inverse of this matrix. + + + + Computes the Kronecker product of this matrix with the given matrix. The new matrix is M-by-N + with M = this.Rows * lower.Rows and N = this.Columns * lower.Columns. + + The other matrix. + The Kronecker product of the two matrices. + + + + Computes the Kronecker product of this matrix with the given matrix. The new matrix is M-by-N + with M = this.Rows * lower.Rows and N = this.Columns * lower.Columns. + + The other matrix. + The Kronecker product of the two matrices. + If the result matrix's dimensions are not (this.Rows * lower.rows) x (this.Columns * lower.Columns). + + + + Pointwise applies the minimum with a scalar to each value. + + The scalar value to compare to. + + + + Pointwise applies the minimum with a scalar to each value. + + The scalar value to compare to. + The vector to store the result. + If this vector and are not the same size. + + + + Pointwise applies the maximum with a scalar to each value. + + The scalar value to compare to. + + + + Pointwise applies the maximum with a scalar to each value. + + The scalar value to compare to. + The matrix to store the result. + If this matrix and are not the same size. + + + + Pointwise applies the absolute minimum with a scalar to each value. + + The scalar value to compare to. + + + + Pointwise applies the absolute minimum with a scalar to each value. + + The scalar value to compare to. + The matrix to store the result. + If this matrix and are not the same size. + + + + Pointwise applies the absolute maximum with a scalar to each value. + + The scalar value to compare to. + + + + Pointwise applies the absolute maximum with a scalar to each value. + + The scalar value to compare to. + The matrix to store the result. + If this matrix and are not the same size. + + + + Pointwise applies the minimum with the values of another matrix to each value. + + The matrix with the values to compare to. + + + + Pointwise applies the minimum with the values of another matrix to each value. + + The matrix with the values to compare to. + The matrix to store the result. + If this matrix and are not the same size. + + + + Pointwise applies the maximum with the values of another matrix to each value. + + The matrix with the values to compare to. + + + + Pointwise applies the maximum with the values of another matrix to each value. + + The matrix with the values to compare to. + The matrix to store the result. + If this matrix and are not the same size. + + + + Pointwise applies the absolute minimum with the values of another matrix to each value. + + The matrix with the values to compare to. + + + + Pointwise applies the absolute minimum with the values of another matrix to each value. + + The matrix with the values to compare to. + The matrix to store the result. + If this matrix and are not the same size. + + + + Pointwise applies the absolute maximum with the values of another matrix to each value. + + The matrix with the values to compare to. + + + + Pointwise applies the absolute maximum with the values of another matrix to each value. + + The matrix with the values to compare to. + The matrix to store the result. + If this matrix and are not the same size. + + + Calculates the induced L1 norm of this matrix. + The maximum absolute column sum of the matrix. + + + Calculates the induced L2 norm of the matrix. + The largest singular value of the matrix. + + For sparse matrices, the L2 norm is computed using a dense implementation of singular value decomposition. + In a later release, it will be replaced with a sparse implementation. + + + + Calculates the induced infinity norm of this matrix. + The maximum absolute row sum of the matrix. + + + Calculates the entry-wise Frobenius norm of this matrix. + The square root of the sum of the squared values. + + + + Calculates the p-norms of all row vectors. + Typical values for p are 1.0 (L1, Manhattan norm), 2.0 (L2, Euclidean norm) and positive infinity (infinity norm) + + + + + Calculates the p-norms of all column vectors. + Typical values for p are 1.0 (L1, Manhattan norm), 2.0 (L2, Euclidean norm) and positive infinity (infinity norm) + + + + + Normalizes all row vectors to a unit p-norm. + Typical values for p are 1.0 (L1, Manhattan norm), 2.0 (L2, Euclidean norm) and positive infinity (infinity norm) + + + + + Normalizes all column vectors to a unit p-norm. + Typical values for p are 1.0 (L1, Manhattan norm), 2.0 (L2, Euclidean norm) and positive infinity (infinity norm) + + + + + Calculates the value sum of each row vector. + + + + + Calculates the value sum of each column vector. + + + + + Calculates the absolute value sum of each row vector. + + + + + Calculates the absolute value sum of each column vector. + + + + + Indicates whether the current object is equal to another object of the same type. + + + An object to compare with this object. + + + true if the current object is equal to the parameter; otherwise, false. + + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + + true if the specified is equal to this instance; otherwise, false. + + + + + Returns a hash code for this instance. + + + A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. + + + + + Creates a new object that is a copy of the current instance. + + + A new object that is a copy of this instance. + + + + + Returns a string that describes the type, dimensions and shape of this matrix. + + + + + Returns a string 2D array that summarizes the content of this matrix. + + + + + Returns a string 2D array that summarizes the content of this matrix. + + + + + Returns a string that summarizes the content of this matrix. + + + + + Returns a string that summarizes the content of this matrix. + + + + + Returns a string that summarizes this matrix. + + + + + Returns a string that summarizes this matrix. + The maximum number of cells can be configured in the class. + + + + + Returns a string that summarizes this matrix. + The maximum number of cells can be configured in the class. + The format string is ignored. + + + + + Initializes a new instance of the Matrix class. + + + + + Gets the raw matrix data storage. + + + + + Gets the number of columns. + + The number of columns. + + + + Gets the number of rows. + + The number of rows. + + + + Gets or sets the value at the given row and column, with range checking. + + + The row of the element. + + + The column of the element. + + The value to get or set. + This method is ranged checked. and + to get and set values without range checking. + + + + Retrieves the requested element without range checking. + + + The row of the element. + + + The column of the element. + + + The requested element. + + + + + Sets the value of the given element without range checking. + + + The row of the element. + + + The column of the element. + + + The value to set the element to. + + + + + Sets all values to zero. + + + + + Sets all values of a row to zero. + + + + + Sets all values of a column to zero. + + + + + Sets all values for all of the chosen rows to zero. + + + + + Sets all values for all of the chosen columns to zero. + + + + + Sets all values of a sub-matrix to zero. + + + + + Set all values whose absolute value is smaller than the threshold to zero, in-place. + + + + + Set all values that meet the predicate to zero, in-place. + + + + + Creates a clone of this instance. + + + A clone of the instance. + + + + + Copies the elements of this matrix to the given matrix. + + + The matrix to copy values into. + + + If target is . + + + If this and the target matrix do not have the same dimensions.. + + + + + Copies a row into an Vector. + + The row to copy. + A Vector containing the copied elements. + If is negative, + or greater than or equal to the number of rows. + + + + Copies a row into to the given Vector. + + The row to copy. + The Vector to copy the row into. + If the result vector is . + If is negative, + or greater than or equal to the number of rows. + If this.Columns != result.Count. + + + + Copies the requested row elements into a new Vector. + + The row to copy elements from. + The column to start copying from. + The number of elements to copy. + A Vector containing the requested elements. + If: + is negative, + or greater than or equal to the number of rows. + is negative, + or greater than or equal to the number of columns. + (columnIndex + length) >= Columns. + If is not positive. + + + + Copies the requested row elements into a new Vector. + + The row to copy elements from. + The column to start copying from. + The number of elements to copy. + The Vector to copy the column into. + If the result Vector is . + If is negative, + or greater than or equal to the number of columns. + If is negative, + or greater than or equal to the number of rows. + If + + is greater than or equal to the number of rows. + If is not positive. + If result.Count < length. + + + + Copies a column into a new Vector>. + + The column to copy. + A Vector containing the copied elements. + If is negative, + or greater than or equal to the number of columns. + + + + Copies a column into to the given Vector. + + The column to copy. + The Vector to copy the column into. + If the result Vector is . + If is negative, + or greater than or equal to the number of columns. + If this.Rows != result.Count. + + + + Copies the requested column elements into a new Vector. + + The column to copy elements from. + The row to start copying from. + The number of elements to copy. + A Vector containing the requested elements. + If: + is negative, + or greater than or equal to the number of columns. + is negative, + or greater than or equal to the number of rows. + (rowIndex + length) >= Rows. + + If is not positive. + + + + Copies the requested column elements into the given vector. + + The column to copy elements from. + The row to start copying from. + The number of elements to copy. + The Vector to copy the column into. + If the result Vector is . + If is negative, + or greater than or equal to the number of columns. + If is negative, + or greater than or equal to the number of rows. + If + + is greater than or equal to the number of rows. + If is not positive. + If result.Count < length. + + + + Returns a new matrix containing the upper triangle of this matrix. + + The upper triangle of this matrix. + + + + Returns a new matrix containing the lower triangle of this matrix. + + The lower triangle of this matrix. + + + + Puts the lower triangle of this matrix into the result matrix. + + Where to store the lower triangle. + If is . + If the result matrix's dimensions are not the same as this matrix. + + + + Puts the upper triangle of this matrix into the result matrix. + + Where to store the lower triangle. + If is . + If the result matrix's dimensions are not the same as this matrix. + + + + Creates a matrix that contains the values from the requested sub-matrix. + + The row to start copying from. + The number of rows to copy. Must be positive. + The column to start copying from. + The number of columns to copy. Must be positive. + The requested sub-matrix. + If: is + negative, or greater than or equal to the number of rows. + is negative, or greater than or equal to the number + of columns. + (columnIndex + columnLength) >= Columns + (rowIndex + rowLength) >= Rows + If or + is not positive. + + + + Returns the elements of the diagonal in a Vector. + + The elements of the diagonal. + For non-square matrices, the method returns Min(Rows, Columns) elements where + i == j (i is the row index, and j is the column index). + + + + Returns a new matrix containing the lower triangle of this matrix. The new matrix + does not contain the diagonal elements of this matrix. + + The lower triangle of this matrix. + + + + Puts the strictly lower triangle of this matrix into the result matrix. + + Where to store the lower triangle. + If is . + If the result matrix's dimensions are not the same as this matrix. + + + + Returns a new matrix containing the upper triangle of this matrix. The new matrix + does not contain the diagonal elements of this matrix. + + The upper triangle of this matrix. + + + + Puts the strictly upper triangle of this matrix into the result matrix. + + Where to store the lower triangle. + If is . + If the result matrix's dimensions are not the same as this matrix. + + + + Creates a new matrix and inserts the given column at the given index. + + The index of where to insert the column. + The column to insert. + A new matrix with the inserted column. + If is . + If is < zero or > the number of columns. + If the size of != the number of rows. + + + + Creates a new matrix with the given column removed. + + The index of the column to remove. + A new matrix without the chosen column. + If is < zero or >= the number of columns. + + + + Copies the values of the given Vector to the specified column. + + The column to copy the values to. + The vector to copy the values from. + If is . + If is less than zero, + or greater than or equal to the number of columns. + If the size of does not + equal the number of rows of this Matrix. + + + + Copies the values of the given Vector to the specified sub-column. + + The column to copy the values to. + The row to start copying to. + The number of elements to copy. + The vector to copy the values from. + If is . + If is less than zero, + or greater than or equal to the number of columns. + If the size of does not + equal the number of rows of this Matrix. + + + + Copies the values of the given array to the specified column. + + The column to copy the values to. + The array to copy the values from. + If is . + If is less than zero, + or greater than or equal to the number of columns. + If the size of does not + equal the number of rows of this Matrix. + If the size of does not + equal the number of rows of this Matrix. + + + + Creates a new matrix and inserts the given row at the given index. + + The index of where to insert the row. + The row to insert. + A new matrix with the inserted column. + If is . + If is < zero or > the number of rows. + If the size of != the number of columns. + + + + Creates a new matrix with the given row removed. + + The index of the row to remove. + A new matrix without the chosen row. + If is < zero or >= the number of rows. + + + + Copies the values of the given Vector to the specified row. + + The row to copy the values to. + The vector to copy the values from. + If is . + If is less than zero, + or greater than or equal to the number of rows. + If the size of does not + equal the number of columns of this Matrix. + + + + Copies the values of the given Vector to the specified sub-row. + + The row to copy the values to. + The column to start copying to. + The number of elements to copy. + The vector to copy the values from. + If is . + If is less than zero, + or greater than or equal to the number of rows. + If the size of does not + equal the number of columns of this Matrix. + + + + Copies the values of the given array to the specified row. + + The row to copy the values to. + The array to copy the values from. + If is . + If is less than zero, + or greater than or equal to the number of rows. + If the size of does not + equal the number of columns of this Matrix. + + + + Copies the values of a given matrix into a region in this matrix. + + The row to start copying to. + The column to start copying to. + The sub-matrix to copy from. + If: is + negative, or greater than or equal to the number of rows. + is negative, or greater than or equal to the number + of columns. + (columnIndex + columnLength) >= Columns + (rowIndex + rowLength) >= Rows + + + + Copies the values of a given matrix into a region in this matrix. + + The row to start copying to. + The number of rows to copy. Must be positive. + The column to start copying to. + The number of columns to copy. Must be positive. + The sub-matrix to copy from. + If: is + negative, or greater than or equal to the number of rows. + is negative, or greater than or equal to the number + of columns. + (columnIndex + columnLength) >= Columns + (rowIndex + rowLength) >= Rows + the size of is not at least x . + If or + is not positive. + + + + Copies the values of a given matrix into a region in this matrix. + + The row to start copying to. + The row of the sub-matrix to start copying from. + The number of rows to copy. Must be positive. + The column to start copying to. + The column of the sub-matrix to start copying from. + The number of columns to copy. Must be positive. + The sub-matrix to copy from. + If: is + negative, or greater than or equal to the number of rows. + is negative, or greater than or equal to the number + of columns. + (columnIndex + columnLength) >= Columns + (rowIndex + rowLength) >= Rows + the size of is not at least x . + If or + is not positive. + + + + Copies the values of the given Vector to the diagonal. + + The vector to copy the values from. The length of the vector should be + Min(Rows, Columns). + If is . + If the length of does not + equal Min(Rows, Columns). + For non-square matrices, the elements of are copied to + this[i,i]. + + + + Copies the values of the given array to the diagonal. + + The array to copy the values from. The length of the vector should be + Min(Rows, Columns). + If is . + If the length of does not + equal Min(Rows, Columns). + For non-square matrices, the elements of are copied to + this[i,i]. + + + + Creates a new matrix with the desired size and copies this matrix to it. + Values which no longer exist in the new matrix are ignored, new values are set to zero. + + The number of rows of the new matrix. + The number of columns of the new matrix. + A new matrix with the desired rows and columns. + + + + Returns the transpose of this matrix. + + The transpose of this matrix. + + + + Puts the transpose of this matrix into the result matrix. + + + + + Returns the conjugate transpose of this matrix. + + The conjugate transpose of this matrix. + + + + Puts the conjugate transpose of this matrix into the result matrix. + + + + + Permute the rows of a matrix according to a permutation. + + The row permutation to apply to this matrix. + + + + Permute the columns of a matrix according to a permutation. + + The column permutation to apply to this matrix. + + + + Concatenates this matrix with the given matrix. + + The matrix to concatenate. + The combined matrix. + + + + + + Concatenates this matrix with the given matrix and places the result into the result matrix. + + The matrix to concatenate. + The combined matrix. + + + + + + Stacks this matrix on top of the given matrix and places the result into the result matrix. + + The matrix to stack this matrix upon. + The combined matrix. + If lower is . + If upper.Columns != lower.Columns. + + + + + + Stacks this matrix on top of the given matrix and places the result into the result matrix. + + The matrix to stack this matrix upon. + The combined matrix. + If lower is . + If upper.Columns != lower.Columns. + + + + + + Diagonally stacks his matrix on top of the given matrix. The new matrix is a M-by-N matrix, + where M = this.Rows + lower.Rows and N = this.Columns + lower.Columns. + The values of off the off diagonal matrices/blocks are set to zero. + + The lower, right matrix. + If lower is . + the combined matrix + + + + + + Diagonally stacks his matrix on top of the given matrix and places the combined matrix into the result matrix. + + The lower, right matrix. + The combined matrix + If lower is . + If the result matrix is . + If the result matrix's dimensions are not (this.Rows + lower.rows) x (this.Columns + lower.Columns). + + + + + + Evaluates whether this matrix is symmetric. + + + + + Evaluates whether this matrix is Hermitian (conjugate symmetric). + + + + + Returns this matrix as a multidimensional array. + The returned array will be independent from this matrix. + A new memory block will be allocated for the array. + + A multidimensional containing the values of this matrix. + + + + Returns the matrix's elements as an array with the data laid out column by column (column major). + The returned array will be independent from this matrix. + A new memory block will be allocated for the array. + + 
    +            1, 2, 3
+            4, 5, 6  will be returned as  1, 4, 7, 2, 5, 8, 3, 6, 9
+            7, 8, 9
+
    + An array containing the matrix's elements. + + +     + + + Returns the matrix's elements as an array with the data laid row by row (row major). + The returned array will be independent from this matrix. + A new memory block will be allocated for the array. + + 
    +            1, 2, 3
+            4, 5, 6  will be returned as  1, 2, 3, 4, 5, 6, 7, 8, 9
+            7, 8, 9
+
    + An array containing the matrix's elements. + + +     + + + Returns this matrix as array of row arrays. + The returned arrays will be independent from this matrix. + A new memory block will be allocated for the arrays. + + + + + Returns this matrix as array of column arrays. + The returned arrays will be independent from this matrix. + A new memory block will be allocated for the arrays. + + + + + Returns the internal multidimensional array of this matrix if, and only if, this matrix is stored by such an array internally. + Otherwise returns null. Changes to the returned array and the matrix will affect each other. + Use ToArray instead if you always need an independent array. + + + + + Returns the internal column by column (column major) array of this matrix if, and only if, this matrix is stored by such arrays internally. + Otherwise returns null. Changes to the returned arrays and the matrix will affect each other. + Use ToColumnMajorArray instead if you always need an independent array. + + 
    +            1, 2, 3
+            4, 5, 6  will be returned as  1, 4, 7, 2, 5, 8, 3, 6, 9
+            7, 8, 9
+
    + An array containing the matrix's elements. + + +     + + + Returns the internal row by row (row major) array of this matrix if, and only if, this matrix is stored by such arrays internally. + Otherwise returns null. Changes to the returned arrays and the matrix will affect each other. + Use ToRowMajorArray instead if you always need an independent array. + + 
    +            1, 2, 3
+            4, 5, 6  will be returned as  1, 2, 3, 4, 5, 6, 7, 8, 9
+            7, 8, 9
+
    + An array containing the matrix's elements. + + +     + + + Returns the internal row arrays of this matrix if, and only if, this matrix is stored by such arrays internally. + Otherwise returns null. Changes to the returned arrays and the matrix will affect each other. + Use ToRowArrays instead if you always need an independent array. + + + + + Returns the internal column arrays of this matrix if, and only if, this matrix is stored by such arrays internally. + Otherwise returns null. Changes to the returned arrays and the matrix will affect each other. + Use ToColumnArrays instead if you always need an independent array. + + + + + Returns an IEnumerable that can be used to iterate through all values of the matrix. + + + The enumerator will include all values, even if they are zero. + The ordering of the values is unspecified (not necessarily column-wise or row-wise). + + + + + Returns an IEnumerable that can be used to iterate through all values of the matrix. + + + The enumerator will include all values, even if they are zero. + The ordering of the values is unspecified (not necessarily column-wise or row-wise). + + + + + Returns an IEnumerable that can be used to iterate through all values of the matrix and their index. + + + The enumerator returns a Tuple with the first two values being the row and column index + and the third value being the value of the element at that index. + The enumerator will include all values, even if they are zero. + + + + + Returns an IEnumerable that can be used to iterate through all values of the matrix and their index. + + + The enumerator returns a Tuple with the first two values being the row and column index + and the third value being the value of the element at that index. + The enumerator will include all values, even if they are zero. + + + + + Returns an IEnumerable that can be used to iterate through all columns of the matrix. + + + + + Returns an IEnumerable that can be used to iterate through a subset of all columns of the matrix. + + The column to start enumerating over. + The number of columns to enumerating over. + + + + Returns an IEnumerable that can be used to iterate through all columns of the matrix and their index. + + + The enumerator returns a Tuple with the first value being the column index + and the second value being the value of the column at that index. + + + + + Returns an IEnumerable that can be used to iterate through a subset of all columns of the matrix and their index. + + The column to start enumerating over. + The number of columns to enumerating over. + + The enumerator returns a Tuple with the first value being the column index + and the second value being the value of the column at that index. + + + + + Returns an IEnumerable that can be used to iterate through all rows of the matrix. + + + + + Returns an IEnumerable that can be used to iterate through a subset of all rows of the matrix. + + The row to start enumerating over. + The number of rows to enumerating over. + + + + Returns an IEnumerable that can be used to iterate through all rows of the matrix and their index. + + + The enumerator returns a Tuple with the first value being the row index + and the second value being the value of the row at that index. + + + + + Returns an IEnumerable that can be used to iterate through a subset of all rows of the matrix and their index. + + The row to start enumerating over. + The number of rows to enumerating over. + + The enumerator returns a Tuple with the first value being the row index + and the second value being the value of the row at that index. + + + + + Applies a function to each value of this matrix and replaces the value with its result. + If forceMapZero is not set to true, zero values may or may not be skipped depending + on the actual data storage implementation (relevant mostly for sparse matrices). + + + + + Applies a function to each value of this matrix and replaces the value with its result. + The row and column indices of each value (zero-based) are passed as first arguments to the function. + If forceMapZero is not set to true, zero values may or may not be skipped depending + on the actual data storage implementation (relevant mostly for sparse matrices). + + + + + Applies a function to each value of this matrix and replaces the value in the result matrix. + If forceMapZero is not set to true, zero values may or may not be skipped depending + on the actual data storage implementation (relevant mostly for sparse matrices). + + + + + Applies a function to each value of this matrix and replaces the value in the result matrix. + The index of each value (zero-based) is passed as first argument to the function. + If forceMapZero is not set to true, zero values may or may not be skipped depending + on the actual data storage implementation (relevant mostly for sparse matrices). + + + + + Applies a function to each value of this matrix and replaces the value in the result matrix. + If forceMapZero is not set to true, zero values may or may not be skipped depending + on the actual data storage implementation (relevant mostly for sparse matrices). + + + + + Applies a function to each value of this matrix and replaces the value in the result matrix. + The index of each value (zero-based) is passed as first argument to the function. + If forceMapZero is not set to true, zero values may or may not be skipped depending + on the actual data storage implementation (relevant mostly for sparse matrices). + + + + + Applies a function to each value of this matrix and returns the results as a new matrix. + If forceMapZero is not set to true, zero values may or may not be skipped depending + on the actual data storage implementation (relevant mostly for sparse matrices). + + + + + Applies a function to each value of this matrix and returns the results as a new matrix. + The index of each value (zero-based) is passed as first argument to the function. + If forceMapZero is not set to true, zero values may or may not be skipped depending + on the actual data storage implementation (relevant mostly for sparse matrices). + + + + + For each row, applies a function f to each element of the row, threading an accumulator argument through the computation. + Returns an array with the resulting accumulator states for each row. + + + + + For each column, applies a function f to each element of the column, threading an accumulator argument through the computation. + Returns an array with the resulting accumulator states for each column. + + + + + Applies a function f to each row vector, threading an accumulator vector argument through the computation. + Returns the resulting accumulator vector. + + + + + Applies a function f to each column vector, threading an accumulator vector argument through the computation. + Returns the resulting accumulator vector. + + + + + Reduces all row vectors by applying a function between two of them, until only a single vector is left. + + + + + Reduces all column vectors by applying a function between two of them, until only a single vector is left. + + + + + Applies a function to each value pair of two matrices and replaces the value in the result vector. + + + + + Applies a function to each value pair of two matrices and returns the results as a new vector. + + + + + Applies a function to update the status with each value pair of two matrices and returns the resulting status. + + + + + Returns a tuple with the index and value of the first element satisfying a predicate, or null if none is found. + Zero elements may be skipped on sparse data structures if allowed (default). + + + + + Returns a tuple with the index and values of the first element pair of two matrices of the same size satisfying a predicate, or null if none is found. + Zero elements may be skipped on sparse data structures if allowed (default). + + + + + Returns true if at least one element satisfies a predicate. + Zero elements may be skipped on sparse data structures if allowed (default). + + + + + Returns true if at least one element pairs of two matrices of the same size satisfies a predicate. + Zero elements may be skipped on sparse data structures if allowed (default). + + + + + Returns true if all elements satisfy a predicate. + Zero elements may be skipped on sparse data structures if allowed (default). + + + + + Returns true if all element pairs of two matrices of the same size satisfy a predicate. + Zero elements may be skipped on sparse data structures if allowed (default). + + + + + Returns a Matrix containing the same values of . + + The matrix to get the values from. + A matrix containing a the same values as . + If is . + + + + Negates each element of the matrix. + + The matrix to negate. + A matrix containing the negated values. + If is . + + + + Adds two matrices together and returns the results. + + This operator will allocate new memory for the result. It will + choose the representation of either or depending on which + is denser. + The left matrix to add. + The right matrix to add. + The result of the addition. + If and don't have the same dimensions. + If or is . + + + + Adds a scalar to each element of the matrix. + + This operator will allocate new memory for the result. It will + choose the representation of the provided matrix. + The left matrix to add. + The scalar value to add. + The result of the addition. + If is . + + + + Adds a scalar to each element of the matrix. + + This operator will allocate new memory for the result. It will + choose the representation of the provided matrix. + The scalar value to add. + The right matrix to add. + The result of the addition. + If is . + + + + Subtracts two matrices together and returns the results. + + This operator will allocate new memory for the result. It will + choose the representation of either or depending on which + is denser. + The left matrix to subtract. + The right matrix to subtract. + The result of the subtraction. + If and don't have the same dimensions. + If or is . + + + + Subtracts a scalar from each element of a matrix. + + This operator will allocate new memory for the result. It will + choose the representation of the provided matrix. + The left matrix to subtract. + The scalar value to subtract. + The result of the subtraction. + If and don't have the same dimensions. + If or is . + + + + Subtracts each element of a matrix from a scalar. + + This operator will allocate new memory for the result. It will + choose the representation of the provided matrix. + The scalar value to subtract. + The right matrix to subtract. + The result of the subtraction. + If and don't have the same dimensions. + If or is . + + + + Multiplies a Matrix by a constant and returns the result. + + The matrix to multiply. + The constant to multiply the matrix by. + The result of the multiplication. + If is . + + + + Multiplies a Matrix by a constant and returns the result. + + The matrix to multiply. + The constant to multiply the matrix by. + The result of the multiplication. + If is . + + + + Multiplies two matrices. + + This operator will allocate new memory for the result. It will + choose the representation of either or depending on which + is denser. + The left matrix to multiply. + The right matrix to multiply. + The result of multiplication. + If or is . + If the dimensions of or don't conform. + + + + Multiplies a Matrix and a Vector. + + The matrix to multiply. + The vector to multiply. + The result of multiplication. + If or is . + + + + Multiplies a Vector and a Matrix. + + The vector to multiply. + The matrix to multiply. + The result of multiplication. + If or is . + + + + Divides a scalar with a matrix. + + The scalar to divide. + The matrix. + The result of the division. + If is . + + + + Divides a matrix with a scalar. + + The matrix to divide. + The scalar value. + The result of the division. + If is . + + + + Computes the pointwise remainder (% operator), where the result has the sign of the dividend, + of each element of the matrix of the given divisor. + + The matrix whose elements we want to compute the modulus of. + The divisor to use. + The result of the calculation + If is . + + + + Computes the pointwise remainder (% operator), where the result has the sign of the dividend, + of the given dividend of each element of the matrix. + + The dividend we want to compute the modulus of. + The matrix whose elements we want to use as divisor. + The result of the calculation + If is . + + + + Computes the pointwise remainder (% operator), where the result has the sign of the dividend, + of each element of two matrices. + + The matrix whose elements we want to compute the remainder of. + The divisor to use. + If and are not the same size. + If is . + + + + Computes the sqrt of a matrix pointwise + + The input matrix + + + + + Computes the exponential of a matrix pointwise + + The input matrix + + + + + Computes the log of a matrix pointwise + + The input matrix + + + + + Computes the log10 of a matrix pointwise + + The input matrix + + + + + Computes the sin of a matrix pointwise + + The input matrix + + + + + Computes the cos of a matrix pointwise + + The input matrix + + + + + Computes the tan of a matrix pointwise + + The input matrix + + + + + Computes the asin of a matrix pointwise + + The input matrix + + + + + Computes the acos of a matrix pointwise + + The input matrix + + + + + Computes the atan of a matrix pointwise + + The input matrix + + + + + Computes the sinh of a matrix pointwise + + The input matrix + + + + + Computes the cosh of a matrix pointwise + + The input matrix + + + + + Computes the tanh of a matrix pointwise + + The input matrix + + + + + Computes the absolute value of a matrix pointwise + + The input matrix + + + + + Computes the floor of a matrix pointwise + + The input matrix + + + + + Computes the ceiling of a matrix pointwise + + The input matrix + + + + + Computes the rounded value of a matrix pointwise + + The input matrix + + + + + Computes the Cholesky decomposition for a matrix. + + The Cholesky decomposition object. + + + + Computes the LU decomposition for a matrix. + + The LU decomposition object. + + + + Computes the QR decomposition for a matrix. + + The type of QR factorization to perform. + The QR decomposition object. + + + + Computes the QR decomposition for a matrix using Modified Gram-Schmidt Orthogonalization. + + The QR decomposition object. + + + + Computes the SVD decomposition for a matrix. + + Compute the singular U and VT vectors or not. + The SVD decomposition object. + + + + Computes the EVD decomposition for a matrix. + + The EVD decomposition object. + + + + Solves a system of linear equations, Ax = b, with A QR factorized. + + The right hand side vector, b. + The left hand side , x. + + + + Solves a system of linear equations, AX = B, with A QR factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, AX = B, with A QR factorized. + + The right hand side , B. + The left hand side , X. + + + + Solves a system of linear equations, Ax = b, with A QR factorized. + + The right hand side vector, b. + The left hand side , x. + + + + Solves the matrix equation Ax = b, where A is the coefficient matrix (this matrix), b is the solution vector and x is the unknown vector. + + The solution vector b. + The result vector x. + The iterative solver to use. + The iterator to use to control when to stop iterating. + The preconditioner to use for approximations. + + + + Solves the matrix equation AX = B, where A is the coefficient matrix (this matrix), B is the solution matrix and X is the unknown matrix. + + The solution matrix B. + The result matrix X + The iterative solver to use. + The iterator to use to control when to stop iterating. + The preconditioner to use for approximations. + + + + Solves the matrix equation Ax = b, where A is the coefficient matrix (this matrix), b is the solution vector and x is the unknown vector. + + The solution vector b. + The result vector x. + The iterative solver to use. + Criteria to control when to stop iterating. + The preconditioner to use for approximations. + + + + Solves the matrix equation AX = B, where A is the coefficient matrix (this matrix), B is the solution matrix and X is the unknown matrix. + + The solution matrix B. + The result matrix X + The iterative solver to use. + Criteria to control when to stop iterating. + The preconditioner to use for approximations. + + + + Solves the matrix equation Ax = b, where A is the coefficient matrix (this matrix), b is the solution vector and x is the unknown vector. + + The solution vector b. + The result vector x. + The iterative solver to use. + Criteria to control when to stop iterating. + + + + Solves the matrix equation AX = B, where A is the coefficient matrix (this matrix), B is the solution matrix and X is the unknown matrix. + + The solution matrix B. + The result matrix X + The iterative solver to use. + Criteria to control when to stop iterating. + + + + Solves the matrix equation Ax = b, where A is the coefficient matrix (this matrix), b is the solution vector and x is the unknown vector. + + The solution vector b. + The iterative solver to use. + The iterator to use to control when to stop iterating. + The preconditioner to use for approximations. + The result vector x. + + + + Solves the matrix equation AX = B, where A is the coefficient matrix (this matrix), B is the solution matrix and X is the unknown matrix. + + The solution matrix B. + The iterative solver to use. + The iterator to use to control when to stop iterating. + The preconditioner to use for approximations. + The result matrix X. + + + + Solves the matrix equation Ax = b, where A is the coefficient matrix (this matrix), b is the solution vector and x is the unknown vector. + + The solution vector b. + The iterative solver to use. + Criteria to control when to stop iterating. + The preconditioner to use for approximations. + The result vector x. + + + + Solves the matrix equation AX = B, where A is the coefficient matrix (this matrix), B is the solution matrix and X is the unknown matrix. + + The solution matrix B. + The iterative solver to use. + Criteria to control when to stop iterating. + The preconditioner to use for approximations. + The result matrix X. + + + + Solves the matrix equation Ax = b, where A is the coefficient matrix (this matrix), b is the solution vector and x is the unknown vector. + + The solution vector b. + The iterative solver to use. + Criteria to control when to stop iterating. + The result vector x. + + + + Solves the matrix equation AX = B, where A is the coefficient matrix (this matrix), B is the solution matrix and X is the unknown matrix. + + The solution matrix B. + The iterative solver to use. + Criteria to control when to stop iterating. + The result matrix X. + + + + Converts a matrix to single precision. + + + + + Converts a matrix to double precision. + + + + + Converts a matrix to single precision complex numbers. + + + + + Converts a matrix to double precision complex numbers. + + + + + Gets a single precision complex matrix with the real parts from the given matrix. + + + + + Gets a double precision complex matrix with the real parts from the given matrix. + + + + + Gets a real matrix representing the real parts of a complex matrix. + + + + + Gets a real matrix representing the real parts of a complex matrix. + + + + + Gets a real matrix representing the imaginary parts of a complex matrix. + + + + + Gets a real matrix representing the imaginary parts of a complex matrix. + + + + + Existing data may not be all zeros, so clearing may be necessary + if not all of it will be overwritten anyway. + + + + + If existing data is assumed to be all zeros already, + clearing it may be skipped if applicable. + + + + + Allow skipping zero entries (without enforcing skipping them). + When enumerating sparse matrices this can significantly speed up operations. + + + + + Force applying the operation to all fields even if they are zero. + + + + + It is not known yet whether a matrix is symmetric or not. + + + + + A matrix is symmetric + + + + + A matrix is Hermitian (conjugate symmetric). + + + + + A matrix is not symmetric + + + + + Defines an that uses a cancellation token as stop criterion. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + + + + Determines the status of the iterative calculation based on the stop criteria stored + by the current . Result is set into Status field. + + The number of iterations that have passed so far. + The vector containing the current solution values. + The right hand side vector. + The vector containing the current residual vectors. + + The individual stop criteria may internally track the progress of the calculation based + on the invocation of this method. Therefore this method should only be called if the + calculation has moved forwards at least one step. + + + + + Gets the current calculation status. + + + + + Resets the to the pre-calculation state. + + + + + Clones the current and its settings. + + A new instance of the class. + + + + Stop criterion that delegates the status determination to a delegate. + + + + + Create a new instance of this criterion with a custom implementation. + + Custom implementation with the same signature and semantics as the DetermineStatus method. + + + + Determines the status of the iterative calculation by delegating it to the provided delegate. + Result is set into Status field. + + The number of iterations that have passed so far. + The vector containing the current solution values. + The right hand side vector. + The vector containing the current residual vectors. + + The individual stop criteria may internally track the progress of the calculation based + on the invocation of this method. Therefore this method should only be called if the + calculation has moved forwards at least one step. + + + + + Gets the current calculation status. + + + + + Resets the IIterationStopCriterion to the pre-calculation state. + + + + + Clones this criterion and its settings. + + + + + Monitors an iterative calculation for signs of divergence. + + + + + The maximum relative increase the residual may experience without triggering a divergence warning. + + + + + The number of iterations over which a residual increase should be tracked before issuing a divergence warning. + + + + + The status of the calculation + + + + + The array that holds the tracking information. + + + + + The iteration number of the last iteration. + + + + + Initializes a new instance of the class with the specified maximum + relative increase and the specified minimum number of tracking iterations. + + The maximum relative increase that the residual may experience before a divergence warning is issued. + The minimum number of iterations over which the residual must grow before a divergence warning is issued. + + + + Gets or sets the maximum relative increase that the residual may experience before a divergence warning is issued. + + Thrown if the Maximum is set to zero or below. + + + + Gets or sets the minimum number of iterations over which the residual must grow before + issuing a divergence warning. + + Thrown if the value is set to less than one. + + + + Determines the status of the iterative calculation based on the stop criteria stored + by the current . Result is set into Status field. + + The number of iterations that have passed so far. + The vector containing the current solution values. + The right hand side vector. + The vector containing the current residual vectors. + + The individual stop criteria may internally track the progress of the calculation based + on the invocation of this method. Therefore this method should only be called if the + calculation has moved forwards at least one step. + + + + + Detect if solution is diverging + + true if diverging, otherwise false + + + + Gets required history Length + + + + + Gets the current calculation status. + + + + + Resets the to the pre-calculation state. + + + + + Clones the current and its settings. + + A new instance of the class. + + + + Defines an that monitors residuals for NaN's. + + + + + The status of the calculation + + + + + The iteration number of the last iteration. + + + + + Determines the status of the iterative calculation based on the stop criteria stored + by the current . Result is set into Status field. + + The number of iterations that have passed so far. + The vector containing the current solution values. + The right hand side vector. + The vector containing the current residual vectors. + + The individual stop criteria may internally track the progress of the calculation based + on the invocation of this method. Therefore this method should only be called if the + calculation has moved forwards at least one step. + + + + + Gets the current calculation status. + + + + + Resets the to the pre-calculation state. + + + + + Clones the current and its settings. + + A new instance of the class. + + + + The base interface for classes that provide stop criteria for iterative calculations. + + + + + Determines the status of the iterative calculation based on the stop criteria stored + by the current IIterationStopCriterion. Status is set to Status field of current object. + + The number of iterations that have passed so far. + The vector containing the current solution values. + The right hand side vector. + The vector containing the current residual vectors. + + The individual stop criteria may internally track the progress of the calculation based + on the invocation of this method. Therefore this method should only be called if the + calculation has moved forwards at least one step. + + + + + Gets the current calculation status. + + is not a legal value. Status should be set in implementation. + + + + Resets the IIterationStopCriterion to the pre-calculation state. + + To implementers: Invoking this method should not clear the user defined + property values, only the state that is used to track the progress of the + calculation. + + + + Defines the interface for classes that solve the matrix equation Ax = b in + an iterative manner. + + + + + Solves the matrix equation Ax = b, where A is the coefficient matrix, b is the + solution vector and x is the unknown vector. + + The coefficient matrix, A. + The solution vector, b + The result vector, x + The iterator to use to control when to stop iterating. + The preconditioner to use for approximations. + + + + Defines the interface for objects that can create an iterative solver with + specific settings. This interface is used to pass iterative solver creation + setup information around. + + + + + Gets the type of the solver that will be created by this setup object. + + + + + Gets type of preconditioner, if any, that will be created by this setup object. + + + + + Creates the iterative solver to be used. + + + + + Creates the preconditioner to be used by default (can be overwritten). + + + + + Gets the relative speed of the solver. + + Returns a value between 0 and 1, inclusive. + + + + Gets the relative reliability of the solver. + + Returns a value between 0 and 1 inclusive. + + + + The base interface for preconditioner classes. + + + + Preconditioners are used by iterative solvers to improve the convergence + speed of the solving process. Increase in convergence speed + is related to the number of iterations necessary to get a converged solution. + So while in general the use of a preconditioner means that the iterative + solver will perform fewer iterations it does not guarantee that the actual + solution time decreases given that some preconditioners can be expensive to + setup and run. + + + Note that in general changes to the matrix will invalidate the preconditioner + if the changes occur after creating the preconditioner. + + + + + + Initializes the preconditioner and loads the internal data structures. + + The matrix on which the preconditioner is based. + + + + Approximates the solution to the matrix equation Mx = b. + + The right hand side vector. + The left hand side vector. Also known as the result vector. + + + + Defines an that monitors the numbers of iteration + steps as stop criterion. + + + + + The default value for the maximum number of iterations the process is allowed + to perform. + + + + + The maximum number of iterations the calculation is allowed to perform. + + + + + The status of the calculation + + + + + Initializes a new instance of the class with the default maximum + number of iterations. + + + + + Initializes a new instance of the class with the specified maximum + number of iterations. + + The maximum number of iterations the calculation is allowed to perform. + + + + Gets or sets the maximum number of iterations the calculation is allowed to perform. + + Thrown if the Maximum is set to a negative value. + + + + Returns the maximum number of iterations to the default. + + + + + Determines the status of the iterative calculation based on the stop criteria stored + by the current . Result is set into Status field. + + The number of iterations that have passed so far. + The vector containing the current solution values. + The right hand side vector. + The vector containing the current residual vectors. + + The individual stop criteria may internally track the progress of the calculation based + on the invocation of this method. Therefore this method should only be called if the + calculation has moved forwards at least one step. + + + + + Gets the current calculation status. + + + + + Resets the to the pre-calculation state. + + + + + Clones the current and its settings. + + A new instance of the class. + + + + Iterative Calculation Status + + + + + An iterator that is used to check if an iterative calculation should continue or stop. + + + + + The collection that holds all the stop criteria and the flag indicating if they should be added + to the child iterators. + + + + + The status of the iterator. + + + + + Initializes a new instance of the class with the default stop criteria. + + + + + Initializes a new instance of the class with the specified stop criteria. + + + The specified stop criteria. Only one stop criterion of each type can be passed in. None + of the stop criteria will be passed on to child iterators. + + + + + Initializes a new instance of the class with the specified stop criteria. + + + The specified stop criteria. Only one stop criterion of each type can be passed in. None + of the stop criteria will be passed on to child iterators. + + + + + Gets the current calculation status. + + + + + Determines the status of the iterative calculation based on the stop criteria stored + by the current . Result is set into Status field. + + The number of iterations that have passed so far. + The vector containing the current solution values. + The right hand side vector. + The vector containing the current residual vectors. + + The individual iterators may internally track the progress of the calculation based + on the invocation of this method. Therefore this method should only be called if the + calculation has moved forwards at least one step. + + + + + Indicates to the iterator that the iterative process has been cancelled. + + + Does not reset the stop-criteria. + + + + + Resets the to the pre-calculation state. + + + + + Creates a deep clone of the current iterator. + + The deep clone of the current iterator. + + + + Defines an that monitors residuals as stop criterion. + + + + + The maximum value for the residual below which the calculation is considered converged. + + + + + The minimum number of iterations for which the residual has to be below the maximum before + the calculation is considered converged. + + + + + The status of the calculation + + + + + The number of iterations since the residuals got below the maximum. + + + + + The iteration number of the last iteration. + + + + + Initializes a new instance of the class with the specified + maximum residual and minimum number of iterations. + + + The maximum value for the residual below which the calculation is considered converged. + + + The minimum number of iterations for which the residual has to be below the maximum before + the calculation is considered converged. + + + + + Gets or sets the maximum value for the residual below which the calculation is considered + converged. + + Thrown if the Maximum is set to a negative value. + + + + Gets or sets the minimum number of iterations for which the residual has to be + below the maximum before the calculation is considered converged. + + Thrown if the BelowMaximumFor is set to a value less than 1. + + + + Determines the status of the iterative calculation based on the stop criteria stored + by the current . Result is set into Status field. + + The number of iterations that have passed so far. + The vector containing the current solution values. + The right hand side vector. + The vector containing the current residual vectors. + + The individual stop criteria may internally track the progress of the calculation based + on the invocation of this method. Therefore this method should only be called if the + calculation has moved forwards at least one step. + + + + + Gets the current calculation status. + + + + + Resets the to the pre-calculation state. + + + + + Clones the current and its settings. + + A new instance of the class. + + + + Loads the available objects from the specified assembly. + + The assembly which will be searched for setup objects. + If true, types that fail to load are simply ignored. Otherwise the exception is rethrown. + The types that should not be loaded. + + + + Loads the available objects from the specified assembly. + + The type in the assembly which should be searched for setup objects. + If true, types that fail to load are simply ignored. Otherwise the exception is rethrown. + The types that should not be loaded. + + + + Loads the available objects from the specified assembly. + + The of the assembly that should be searched for setup objects. + If true, types that fail to load are simply ignored. Otherwise the exception is rethrown. + The types that should not be loaded. + + + + Loads the available objects from the Math.NET Numerics assembly. + + The types that should not be loaded. + + + + Loads the available objects from the Math.NET Numerics assembly. + + + + + A unit preconditioner. This preconditioner does not actually do anything + it is only used when running an without + a preconditioner. + + + + + The coefficient matrix on which this preconditioner operates. + Is used to check dimensions on the different vectors that are processed. + + + + + Initializes the preconditioner and loads the internal data structures. + + + The matrix upon which the preconditioner is based. + + If is not a square matrix. + + + + Approximates the solution to the matrix equation Ax = b. + + The right hand side vector. + The left hand side vector. Also known as the result vector. + + + If and do not have the same size. + + + - or - + + + If the size of is different the number of rows of the coefficient matrix. + + + + + + True if the matrix storage format is dense. + + + + + True if all fields of this matrix can be set to any value. + False if some fields are fixed, like on a diagonal matrix. + + + + + True if the specified field can be set to any value. + False if the field is fixed, like an off-diagonal field on a diagonal matrix. + + + + + Retrieves the requested element without range checking. + + + + + Sets the element without range checking. + + + + + Evaluate the row and column at a specific data index. + + + + + True if the vector storage format is dense. + + + + + Retrieves the requested element without range checking. + + + + + Sets the element without range checking. + + + + + True if the matrix storage format is dense. + + + + + True if all fields of this matrix can be set to any value. + False if some fields are fixed, like on a diagonal matrix. + + + + + True if the specified field can be set to any value. + False if the field is fixed, like an off-diagonal field on a diagonal matrix. + + + + + Retrieves the requested element without range checking. + + + + + Sets the element without range checking. + + + + + Returns a hash code for this instance. + + + A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. + + + + + True if the matrix storage format is dense. + + + + + True if all fields of this matrix can be set to any value. + False if some fields are fixed, like on a diagonal matrix. + + + + + True if the specified field can be set to any value. + False if the field is fixed, like an off-diagonal field on a diagonal matrix. + + + + + Gets or sets the value at the given row and column, with range checking. + + + The row of the element. + + + The column of the element. + + The value to get or set. + This method is ranged checked. and + to get and set values without range checking. + + + + Retrieves the requested element without range checking. + + + The row of the element. + + + The column of the element. + + + The requested element. + + Not range-checked. + + + + Sets the element without range checking. + + The row of the element. + The column of the element. + The value to set the element to. + WARNING: This method is not thread safe. Use "lock" with it and be sure to avoid deadlocks. + + + + Indicates whether the current object is equal to another object of the same type. + + + An object to compare with this object. + + + true if the current object is equal to the parameter; otherwise, false. + + + + + Determines whether the specified is equal to the current . + + + true if the specified is equal to the current ; otherwise, false. + + The to compare with the current . + + + + Serves as a hash function for a particular type. + + + A hash code for the current . + + + + The state array will not be modified, unless it is the same instance as the target array (which is allowed). + + + The state array will not be modified, unless it is the same instance as the target array (which is allowed). + + + The state array will not be modified, unless it is the same instance as the target array (which is allowed). + + + The state array will not be modified, unless it is the same instance as the target array (which is allowed). + + + + The array containing the row indices of the existing rows. Element "i" of the array gives the index of the + element in the array that is first non-zero element in a row "i". + The last value is equal to ValueCount, so that the number of non-zero entries in row "i" is always + given by RowPointers[i+i] - RowPointers[i]. This array thus has length RowCount+1. + + + + + An array containing the column indices of the non-zero values. Element "j" of the array + is the number of the column in matrix that contains the j-th value in the array. + + + + + Array that contains the non-zero elements of matrix. Values of the non-zero elements of matrix are mapped into the values + array using the row-major storage mapping described in a compressed sparse row (CSR) format. + + + + + Gets the number of non zero elements in the matrix. + + The number of non zero elements. + + + + True if the matrix storage format is dense. + + + + + True if all fields of this matrix can be set to any value. + False if some fields are fixed, like on a diagonal matrix. + + + + + True if the specified field can be set to any value. + False if the field is fixed, like an off-diagonal field on a diagonal matrix. + + + + + Retrieves the requested element without range checking. + + + The row of the element. + + + The column of the element. + + + The requested element. + + Not range-checked. + + + + Sets the element without range checking. + + The row of the element. + The column of the element. + The value to set the element to. + WARNING: This method is not thread safe. Use "lock" with it and be sure to avoid deadlocks. + + + + Delete value from internal storage + + Index of value in nonZeroValues array + Row number of matrix + WARNING: This method is not thread safe. Use "lock" with it and be sure to avoid deadlocks + + + + Find item Index in nonZeroValues array + + Matrix row index + Matrix column index + Item index + WARNING: This method is not thread safe. Use "lock" with it and be sure to avoid deadlocks + + + + Calculates the amount with which to grow the storage array's if they need to be + increased in size. + + The amount grown. + + + + Eliminate duplicate entries by adding them together. + + + + + Fill zeros explicitly on the diagonal entries as required by the Intel MKL direct sparse solver. + + + + + Returns a hash code for this instance. + + + A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. + + + + + Create a new sparse storage from a compressed sparse row (CSR) format. + This new storage will be independent from the given arrays. + A new memory block will be allocated for storing the matrix. + + The number of rows. + The number of columns. + The number of stored values including explicit zeros. + The row pointer array of the compressed sparse row format. + The column index array of the compressed sparse row format. + The data array of the compressed sparse row format. + The sparse storage from the compressed sparse row format. + Duplicate entries will be summed together and explicit zeros will be not intentionally removed. + + + + Create a new sparse matrix storage from a compressed sparse column (CSC) format. + This new storage will be independent from the given arrays. + A new memory block will be allocated. + + The number of rows. + The number of columns. + The number of stored values including explicit zeros. + The row index array of the compressed sparse column format. + The column pointer array of the compressed sparse column format. + The data array of the compressed sparse column format. + The sparse storage from the compressed sparse column format. + Duplicate entries will be summed together and explicit zeros will be not intentionally removed. + + + + Create a new sparse storage from a coordinate (COO) format. + This new storage will be independent from the given arrays. + A new memory block will be allocated for storing the matrix. + + The number of rows. + The number of columns. + The number of stored values including explicit zeros. + The row index array of the coordinate format. + The column index array of the coordinate format. + The data array of the coordinate format. + The sparse storage from the coordinate format. + Duplicate entries will be summed together and + explicit zeros will be not intentionally removed. + + + + Array that contains the indices of the non-zero values. + + + + + Array that contains the non-zero elements of the vector. + + + + + Gets the number of non-zero elements in the vector. + + + + + True if the vector storage format is dense. + + + + + Retrieves the requested element without range checking. + + + + + Sets the element without range checking. + + + + + Calculates the amount with which to grow the storage array's if they need to be + increased in size. + + The amount grown. + + + + Returns a hash code for this instance. + + + A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. + + + + + True if the vector storage format is dense. + + + + + Gets or sets the value at the given index, with range checking. + + + The index of the element. + + The value to get or set. + This method is ranged checked. and + to get and set values without range checking. + + + + Retrieves the requested element without range checking. + + The index of the element. + The requested element. + Not range-checked. + + + + Sets the element without range checking. + + The index of the element. + The value to set the element to. + WARNING: This method is not thread safe. Use "lock" with it and be sure to avoid deadlocks. + + + + Indicates whether the current object is equal to another object of the same type. + + + An object to compare with this object. + + + true if the current object is equal to the parameter; otherwise, false. + + + + + Determines whether the specified is equal to the current . + + + true if the specified is equal to the current ; otherwise, false. + + The to compare with the current . + + + + Serves as a hash function for a particular type. + + + A hash code for the current . + + + + + Defines the generic class for Vector classes. + + Supported data types are double, single, , and . + + + + The zero value for type T. + + + + + The value of 1.0 for type T. + + + + + Negates vector and save result to + + Target vector + + + + Complex conjugates vector and save result to + + Target vector + + + + Adds a scalar to each element of the vector and stores the result in the result vector. + + The scalar to add. + The vector to store the result of the addition. + + + + Adds another vector to this vector and stores the result into the result vector. + + The vector to add to this one. + The vector to store the result of the addition. + + + + Subtracts a scalar from each element of the vector and stores the result in the result vector. + + The scalar to subtract. + The vector to store the result of the subtraction. + + + + Subtracts each element of the vector from a scalar and stores the result in the result vector. + + The scalar to subtract from. + The vector to store the result of the subtraction. + + + + Subtracts another vector to this vector and stores the result into the result vector. + + The vector to subtract from this one. + The vector to store the result of the subtraction. + + + + Multiplies a scalar to each element of the vector and stores the result in the result vector. + + The scalar to multiply. + The vector to store the result of the multiplication. + + + + Computes the dot product between this vector and another vector. + + The other vector. + The sum of a[i]*b[i] for all i. + + + + Computes the dot product between the conjugate of this vector and another vector. + + The other vector. + The sum of conj(a[i])*b[i] for all i. + + + + Computes the outer product M[i,j] = u[i]*v[j] of this and another vector and stores the result in the result matrix. + + The other vector + The matrix to store the result of the product. + + + + Divides each element of the vector by a scalar and stores the result in the result vector. + + The scalar denominator to use. + The vector to store the result of the division. + + + + Divides a scalar by each element of the vector and stores the result in the result vector. + + The scalar numerator to use. + The vector to store the result of the division. + + + + Computes the canonical modulus, where the result has the sign of the divisor, + for each element of the vector for the given divisor. + + The scalar denominator to use. + A vector to store the results in. + + + + Computes the canonical modulus, where the result has the sign of the divisor, + for the given dividend for each element of the vector. + + The scalar numerator to use. + A vector to store the results in. + + + + Computes the remainder (% operator), where the result has the sign of the dividend, + for each element of the vector for the given divisor. + + The scalar denominator to use. + A vector to store the results in. + + + + Computes the remainder (% operator), where the result has the sign of the dividend, + for the given dividend for each element of the vector. + + The scalar numerator to use. + A vector to store the results in. + + + + Pointwise multiplies this vector with another vector and stores the result into the result vector. + + The vector to pointwise multiply with this one. + The vector to store the result of the pointwise multiplication. + + + + Pointwise divide this vector with another vector and stores the result into the result vector. + + The pointwise denominator vector to use. + The result of the division. + + + + Pointwise raise this vector to an exponent and store the result into the result vector. + + The exponent to raise this vector values to. + The vector to store the result of the pointwise power. + + + + Pointwise raise this vector to an exponent vector and store the result into the result vector. + + The exponent vector to raise this vector values to. + The vector to store the result of the pointwise power. + + + + Pointwise canonical modulus, where the result has the sign of the divisor, + of this vector with another vector and stores the result into the result vector. + + The pointwise denominator vector to use. + The result of the modulus. + + + + Pointwise remainder (% operator), where the result has the sign of the dividend, + of this vector with another vector and stores the result into the result vector. + + The pointwise denominator vector to use. + The result of the modulus. + + + + Pointwise applies the exponential function to each value and stores the result into the result vector. + + The vector to store the result. + + + + Pointwise applies the natural logarithm function to each value and stores the result into the result vector. + + The vector to store the result. + + + + Adds a scalar to each element of the vector. + + The scalar to add. + A copy of the vector with the scalar added. + + + + Adds a scalar to each element of the vector and stores the result in the result vector. + + The scalar to add. + The vector to store the result of the addition. + If this vector and are not the same size. + + + + Adds another vector to this vector. + + The vector to add to this one. + A new vector containing the sum of both vectors. + If this vector and are not the same size. + + + + Adds another vector to this vector and stores the result into the result vector. + + The vector to add to this one. + The vector to store the result of the addition. + If this vector and are not the same size. + If this vector and are not the same size. + + + + Subtracts a scalar from each element of the vector. + + The scalar to subtract. + A new vector containing the subtraction of this vector and the scalar. + + + + Subtracts a scalar from each element of the vector and stores the result in the result vector. + + The scalar to subtract. + The vector to store the result of the subtraction. + If this vector and are not the same size. + + + + Subtracts each element of the vector from a scalar. + + The scalar to subtract from. + A new vector containing the subtraction of the scalar and this vector. + + + + Subtracts each element of the vector from a scalar and stores the result in the result vector. + + The scalar to subtract from. + The vector to store the result of the subtraction. + If this vector and are not the same size. + + + + Returns a negated vector. + + The negated vector. + Added as an alternative to the unary negation operator. + + + + Negates vector and save result to + + Target vector + + + + Subtracts another vector from this vector. + + The vector to subtract from this one. + A new vector containing the subtraction of the two vectors. + If this vector and are not the same size. + + + + Subtracts another vector to this vector and stores the result into the result vector. + + The vector to subtract from this one. + The vector to store the result of the subtraction. + If this vector and are not the same size. + If this vector and are not the same size. + + + + Return vector with complex conjugate values of the source vector + + Conjugated vector + + + + Complex conjugates vector and save result to + + Target vector + + + + Multiplies a scalar to each element of the vector. + + The scalar to multiply. + A new vector that is the multiplication of the vector and the scalar. + + + + Multiplies a scalar to each element of the vector and stores the result in the result vector. + + The scalar to multiply. + The vector to store the result of the multiplication. + If this vector and are not the same size. + + + + Computes the dot product between this vector and another vector. + + The other vector. + The sum of a[i]*b[i] for all i. + If is not of the same size. + + + + + Computes the dot product between the conjugate of this vector and another vector. + + The other vector. + The sum of conj(a[i])*b[i] for all i. + If is not of the same size. + If is . + + + + + Divides each element of the vector by a scalar. + + The scalar to divide with. + A new vector that is the division of the vector and the scalar. + + + + Divides each element of the vector by a scalar and stores the result in the result vector. + + The scalar to divide with. + The vector to store the result of the division. + If this vector and are not the same size. + + + + Divides a scalar by each element of the vector. + + The scalar to divide. + A new vector that is the division of the vector and the scalar. + + + + Divides a scalar by each element of the vector and stores the result in the result vector. + + The scalar to divide. + The vector to store the result of the division. + If this vector and are not the same size. + + + + Computes the canonical modulus, where the result has the sign of the divisor, + for each element of the vector for the given divisor. + + The scalar denominator to use. + A vector containing the result. + + + + Computes the canonical modulus, where the result has the sign of the divisor, + for each element of the vector for the given divisor. + + The scalar denominator to use. + A vector to store the results in. + + + + Computes the canonical modulus, where the result has the sign of the divisor, + for the given dividend for each element of the vector. + + The scalar numerator to use. + A vector containing the result. + + + + Computes the canonical modulus, where the result has the sign of the divisor, + for the given dividend for each element of the vector. + + The scalar numerator to use. + A vector to store the results in. + + + + Computes the remainder (vector % divisor), where the result has the sign of the dividend, + for each element of the vector for the given divisor. + + The scalar denominator to use. + A vector containing the result. + + + + Computes the remainder (vector % divisor), where the result has the sign of the dividend, + for each element of the vector for the given divisor. + + The scalar denominator to use. + A vector to store the results in. + + + + Computes the remainder (dividend % vector), where the result has the sign of the dividend, + for the given dividend for each element of the vector. + + The scalar numerator to use. + A vector containing the result. + + + + Computes the remainder (dividend % vector), where the result has the sign of the dividend, + for the given dividend for each element of the vector. + + The scalar numerator to use. + A vector to store the results in. + + + + Pointwise multiplies this vector with another vector. + + The vector to pointwise multiply with this one. + A new vector which is the pointwise multiplication of the two vectors. + If this vector and are not the same size. + + + + Pointwise multiplies this vector with another vector and stores the result into the result vector. + + The vector to pointwise multiply with this one. + The vector to store the result of the pointwise multiplication. + If this vector and are not the same size. + If this vector and are not the same size. + + + + Pointwise divide this vector with another vector. + + The pointwise denominator vector to use. + A new vector which is the pointwise division of the two vectors. + If this vector and are not the same size. + + + + Pointwise divide this vector with another vector and stores the result into the result vector. + + The pointwise denominator vector to use. + The vector to store the result of the pointwise division. + If this vector and are not the same size. + If this vector and are not the same size. + + + + Pointwise raise this vector to an exponent. + + The exponent to raise this vector values to. + + + + Pointwise raise this vector to an exponent and store the result into the result vector. + + The exponent to raise this vector values to. + The matrix to store the result into. + If this vector and are not the same size. + + + + Pointwise raise this vector to an exponent and store the result into the result vector. + + The exponent to raise this vector values to. + + + + Pointwise raise this vector to an exponent. + + The exponent to raise this vector values to. + The vector to store the result into. + If this vector and are not the same size. + + + + Pointwise canonical modulus, where the result has the sign of the divisor, + of this vector with another vector. + + The pointwise denominator vector to use. + If this vector and are not the same size. + + + + Pointwise canonical modulus, where the result has the sign of the divisor, + of this vector with another vector and stores the result into the result vector. + + The pointwise denominator vector to use. + The vector to store the result of the pointwise modulus. + If this vector and are not the same size. + If this vector and are not the same size. + + + + Pointwise remainder (% operator), where the result has the sign of the dividend, + of this vector with another vector. + + The pointwise denominator vector to use. + If this vector and are not the same size. + + + + Pointwise remainder (% operator), where the result has the sign of the dividend, + this vector with another vector and stores the result into the result vector. + + The pointwise denominator vector to use. + The vector to store the result of the pointwise remainder. + If this vector and are not the same size. + If this vector and are not the same size. + + + + Helper function to apply a unary function to a vector. The function + f modifies the vector given to it in place. Before its + called, a copy of the 'this' vector with the same dimension is + first created, then passed to f. The copy is returned as the result + + Function which takes a vector, modifies it in place and returns void + New instance of vector which is the result + + + + Helper function to apply a unary function which modifies a vector + in place. + + Function which takes a vector, modifies it in place and returns void + The vector where the result is to be stored + If this vector and are not the same size. + + + + Helper function to apply a binary function which takes a scalar and + a vector and modifies the latter in place. A copy of the "this" + vector is therefore first made and then passed to f together with + the scalar argument. The copy is then returned as the result + + Function which takes a scalar and a vector, modifies the vector in place and returns void + The scalar to be passed to the function + The resulting vector + + + + Helper function to apply a binary function which takes a scalar and + a vector, modifies the latter in place and returns void. + + Function which takes a scalar and a vector, modifies the vector in place and returns void + The scalar to be passed to the function + The vector where the result will be placed + If this vector and are not the same size. + + + + Helper function to apply a binary function which takes two vectors + and modifies the latter in place. A copy of the "this" vector is + first made and then passed to f together with the other vector. The + copy is then returned as the result + + Function which takes two vectors, modifies the second in place and returns void + The other vector to be passed to the function as argument. It is not modified + The resulting vector + If this vector and are not the same size. + + + + Helper function to apply a binary function which takes two vectors + and modifies the second one in place + + Function which takes two vectors, modifies the second in place and returns void + The other vector to be passed to the function as argument. It is not modified + The resulting vector + If this vector and are not the same size. + + + + Pointwise applies the exponent function to each value. + + + + + Pointwise applies the exponent function to each value. + + The vector to store the result. + If this vector and are not the same size. + + + + Pointwise applies the natural logarithm function to each value. + + + + + Pointwise applies the natural logarithm function to each value. + + The vector to store the result. + If this vector and are not the same size. + + + + Pointwise applies the abs function to each value + + + + + Pointwise applies the abs function to each value + + The vector to store the result + + + + Pointwise applies the acos function to each value + + + + + Pointwise applies the acos function to each value + + The vector to store the result + + + + Pointwise applies the asin function to each value + + + + + Pointwise applies the asin function to each value + + The vector to store the result + + + + Pointwise applies the atan function to each value + + + + + Pointwise applies the atan function to each value + + The vector to store the result + + + + Pointwise applies the atan2 function to each value of the current + vector and a given other vector being the 'x' of atan2 and the + 'this' vector being the 'y' + + + + + + Pointwise applies the atan2 function to each value of the current + vector and a given other vector being the 'x' of atan2 and the + 'this' vector being the 'y' + + + The vector to store the result + + + + Pointwise applies the ceiling function to each value + + + + + Pointwise applies the ceiling function to each value + + The vector to store the result + + + + Pointwise applies the cos function to each value + + + + + Pointwise applies the cos function to each value + + The vector to store the result + + + + Pointwise applies the cosh function to each value + + + + + Pointwise applies the cosh function to each value + + The vector to store the result + + + + Pointwise applies the floor function to each value + + + + + Pointwise applies the floor function to each value + + The vector to store the result + + + + Pointwise applies the log10 function to each value + + + + + Pointwise applies the log10 function to each value + + The vector to store the result + + + + Pointwise applies the round function to each value + + + + + Pointwise applies the round function to each value + + The vector to store the result + + + + Pointwise applies the sign function to each value + + + + + Pointwise applies the sign function to each value + + The vector to store the result + + + + Pointwise applies the sin function to each value + + + + + Pointwise applies the sin function to each value + + The vector to store the result + + + + Pointwise applies the sinh function to each value + + + + + Pointwise applies the sinh function to each value + + The vector to store the result + + + + Pointwise applies the sqrt function to each value + + + + + Pointwise applies the sqrt function to each value + + The vector to store the result + + + + Pointwise applies the tan function to each value + + + + + Pointwise applies the tan function to each value + + The vector to store the result + + + + Pointwise applies the tanh function to each value + + + + + Pointwise applies the tanh function to each value + + The vector to store the result + + + + Computes the outer product M[i,j] = u[i]*v[j] of this and another vector. + + The other vector + + + + Computes the outer product M[i,j] = u[i]*v[j] of this and another vector and stores the result in the result matrix. + + The other vector + The matrix to store the result of the product. + + + + Pointwise applies the minimum with a scalar to each value. + + The scalar value to compare to. + + + + Pointwise applies the minimum with a scalar to each value. + + The scalar value to compare to. + The vector to store the result. + If this vector and are not the same size. + + + + Pointwise applies the maximum with a scalar to each value. + + The scalar value to compare to. + + + + Pointwise applies the maximum with a scalar to each value. + + The scalar value to compare to. + The vector to store the result. + If this vector and are not the same size. + + + + Pointwise applies the absolute minimum with a scalar to each value. + + The scalar value to compare to. + + + + Pointwise applies the absolute minimum with a scalar to each value. + + The scalar value to compare to. + The vector to store the result. + If this vector and are not the same size. + + + + Pointwise applies the absolute maximum with a scalar to each value. + + The scalar value to compare to. + + + + Pointwise applies the absolute maximum with a scalar to each value. + + The scalar value to compare to. + The vector to store the result. + If this vector and are not the same size. + + + + Pointwise applies the minimum with the values of another vector to each value. + + The vector with the values to compare to. + + + + Pointwise applies the minimum with the values of another vector to each value. + + The vector with the values to compare to. + The vector to store the result. + If this vector and are not the same size. + + + + Pointwise applies the maximum with the values of another vector to each value. + + The vector with the values to compare to. + + + + Pointwise applies the maximum with the values of another vector to each value. + + The vector with the values to compare to. + The vector to store the result. + If this vector and are not the same size. + + + + Pointwise applies the absolute minimum with the values of another vector to each value. + + The vector with the values to compare to. + + + + Pointwise applies the absolute minimum with the values of another vector to each value. + + The vector with the values to compare to. + The vector to store the result. + If this vector and are not the same size. + + + + Pointwise applies the absolute maximum with the values of another vector to each value. + + The vector with the values to compare to. + + + + Pointwise applies the absolute maximum with the values of another vector to each value. + + The vector with the values to compare to. + The vector to store the result. + If this vector and are not the same size. + + + + Calculates the L1 norm of the vector, also known as Manhattan norm. + + The sum of the absolute values. + + + + Calculates the L2 norm of the vector, also known as Euclidean norm. + + The square root of the sum of the squared values. + + + + Calculates the infinity norm of the vector. + + The maximum absolute value. + + + + Computes the p-Norm. + + The p value. + Scalar ret = (sum(abs(this[i])^p))^(1/p) + + + + Normalizes this vector to a unit vector with respect to the p-norm. + + The p value. + This vector normalized to a unit vector with respect to the p-norm. + + + + Returns the value of the absolute minimum element. + + The value of the absolute minimum element. + + + + Returns the index of the absolute minimum element. + + The index of absolute minimum element. + + + + Returns the value of the absolute maximum element. + + The value of the absolute maximum element. + + + + Returns the index of the absolute maximum element. + + The index of absolute maximum element. + + + + Returns the value of maximum element. + + The value of maximum element. + + + + Returns the index of the maximum element. + + The index of maximum element. + + + + Returns the value of the minimum element. + + The value of the minimum element. + + + + Returns the index of the minimum element. + + The index of minimum element. + + + + Computes the sum of the vector's elements. + + The sum of the vector's elements. + + + + Computes the sum of the absolute value of the vector's elements. + + The sum of the absolute value of the vector's elements. + + + + Indicates whether the current object is equal to another object of the same type. + + An object to compare with this object. + + true if the current object is equal to the parameter; otherwise, false. + + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + + true if the specified is equal to this instance; otherwise, false. + + + + + Returns a hash code for this instance. + + + A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. + + + + + Creates a new object that is a copy of the current instance. + + + A new object that is a copy of this instance. + + + + + Returns an enumerator that iterates through the collection. + + + A that can be used to iterate through the collection. + + + + + Returns an enumerator that iterates through a collection. + + + An object that can be used to iterate through the collection. + + + + + Returns a string that describes the type, dimensions and shape of this vector. + + + + + Returns a string that represents the content of this vector, column by column. + + Maximum number of entries and thus lines per column. Typical value: 12; Minimum: 3. + Maximum number of characters per line over all columns. Typical value: 80; Minimum: 16. + Character to use to print if there is not enough space to print all entries. Typical value: "..". + Character to use to separate two columns on a line. Typical value: " " (2 spaces). + Character to use to separate two rows/lines. Typical value: Environment.NewLine. + Function to provide a string for any given entry value. + + + + Returns a string that represents the content of this vector, column by column. + + Maximum number of entries and thus lines per column. Typical value: 12; Minimum: 3. + Maximum number of characters per line over all columns. Typical value: 80; Minimum: 16. + Floating point format string. Can be null. Default value: G6. + Format provider or culture. Can be null. + + + + Returns a string that represents the content of this vector, column by column. + + Floating point format string. Can be null. Default value: G6. + Format provider or culture. Can be null. + + + + Returns a string that summarizes this vector, column by column and with a type header. + + Maximum number of entries and thus lines per column. Typical value: 12; Minimum: 3. + Maximum number of characters per line over all columns. Typical value: 80; Minimum: 16. + Floating point format string. Can be null. Default value: G6. + Format provider or culture. Can be null. + + + + Returns a string that summarizes this vector. + The maximum number of cells can be configured in the class. + + + + + Returns a string that summarizes this vector. + The maximum number of cells can be configured in the class. + The format string is ignored. + + + + + Initializes a new instance of the Vector class. + + + + + Gets the raw vector data storage. + + + + + Gets the length or number of dimensions of this vector. + + + + Gets or sets the value at the given . + The index of the value to get or set. + The value of the vector at the given . + If is negative or + greater than the size of the vector. + + + Gets the value at the given without range checking.. + The index of the value to get or set. + The value of the vector at the given . + + + Sets the at the given without range checking.. + The index of the value to get or set. + The value to set. + + + + Resets all values to zero. + + + + + Sets all values of a subvector to zero. + + + + + Set all values whose absolute value is smaller than the threshold to zero, in-place. + + + + + Set all values that meet the predicate to zero, in-place. + + + + + Returns a deep-copy clone of the vector. + + A deep-copy clone of the vector. + + + + Set the values of this vector to the given values. + + The array containing the values to use. + If is . + If is not the same size as this vector. + + + + Copies the values of this vector into the target vector. + + The vector to copy elements into. + If is . + If is not the same size as this vector. + + + + Creates a vector containing specified elements. + + The first element to begin copying from. + The number of elements to copy. + A vector containing a copy of the specified elements. + If is not positive or + greater than or equal to the size of the vector. + If + is greater than or equal to the size of the vector. + + If is not positive. + + + + Copies the values of a given vector into a region in this vector. + + The field to start copying to + The number of fields to copy. Must be positive. + The sub-vector to copy from. + If is + + + + Copies the requested elements from this vector to another. + + The vector to copy the elements to. + The element to start copying from. + The element to start copying to. + The number of elements to copy. + + + + Returns the data contained in the vector as an array. + The returned array will be independent from this vector. + A new memory block will be allocated for the array. + + The vector's data as an array. + + + + Returns the internal array of this vector if, and only if, this vector is stored by such an array internally. + Otherwise returns null. Changes to the returned array and the vector will affect each other. + Use ToArray instead if you always need an independent array. + + + + + Create a matrix based on this vector in column form (one single column). + + + This vector as a column matrix. + + + + + Create a matrix based on this vector in row form (one single row). + + + This vector as a row matrix. + + + + + Returns an IEnumerable that can be used to iterate through all values of the vector. + + + The enumerator will include all values, even if they are zero. + + + + + Returns an IEnumerable that can be used to iterate through all values of the vector. + + + The enumerator will include all values, even if they are zero. + + + + + Returns an IEnumerable that can be used to iterate through all values of the vector and their index. + + + The enumerator returns a Tuple with the first value being the element index + and the second value being the value of the element at that index. + The enumerator will include all values, even if they are zero. + + + + + Returns an IEnumerable that can be used to iterate through all values of the vector and their index. + + + The enumerator returns a Tuple with the first value being the element index + and the second value being the value of the element at that index. + The enumerator will include all values, even if they are zero. + + + + + Applies a function to each value of this vector and replaces the value with its result. + If forceMapZero is not set to true, zero values may or may not be skipped depending + on the actual data storage implementation (relevant mostly for sparse vectors). + + + + + Applies a function to each value of this vector and replaces the value with its result. + The index of each value (zero-based) is passed as first argument to the function. + If forceMapZero is not set to true, zero values may or may not be skipped depending + on the actual data storage implementation (relevant mostly for sparse vectors). + + + + + Applies a function to each value of this vector and replaces the value in the result vector. + If forceMapZero is not set to true, zero values may or may not be skipped depending + on the actual data storage implementation (relevant mostly for sparse vectors). + + + + + Applies a function to each value of this vector and replaces the value in the result vector. + The index of each value (zero-based) is passed as first argument to the function. + If forceMapZero is not set to true, zero values may or may not be skipped depending + on the actual data storage implementation (relevant mostly for sparse vectors). + + + + + Applies a function to each value of this vector and replaces the value in the result vector. + If forceMapZero is not set to true, zero values may or may not be skipped depending + on the actual data storage implementation (relevant mostly for sparse vectors). + + + + + Applies a function to each value of this vector and replaces the value in the result vector. + The index of each value (zero-based) is passed as first argument to the function. + If forceMapZero is not set to true, zero values may or may not be skipped depending + on the actual data storage implementation (relevant mostly for sparse vectors). + + + + + Applies a function to each value of this vector and returns the results as a new vector. + If forceMapZero is not set to true, zero values may or may not be skipped depending + on the actual data storage implementation (relevant mostly for sparse vectors). + + + + + Applies a function to each value of this vector and returns the results as a new vector. + The index of each value (zero-based) is passed as first argument to the function. + If forceMapZero is not set to true, zero values may or may not be skipped depending + on the actual data storage implementation (relevant mostly for sparse vectors). + + + + + Applies a function to each value pair of two vectors and replaces the value in the result vector. + + + + + Applies a function to each value pair of two vectors and returns the results as a new vector. + + + + + Applies a function to update the status with each value pair of two vectors and returns the resulting status. + + + + + Returns a tuple with the index and value of the first element satisfying a predicate, or null if none is found. + Zero elements may be skipped on sparse data structures if allowed (default). + + + + + Returns a tuple with the index and values of the first element pair of two vectors of the same size satisfying a predicate, or null if none is found. + Zero elements may be skipped on sparse data structures if allowed (default). + + + + + Returns true if at least one element satisfies a predicate. + Zero elements may be skipped on sparse data structures if allowed (default). + + + + + Returns true if at least one element pairs of two vectors of the same size satisfies a predicate. + Zero elements may be skipped on sparse data structures if allowed (default). + + + + + Returns true if all elements satisfy a predicate. + Zero elements may be skipped on sparse data structures if allowed (default). + + + + + Returns true if all element pairs of two vectors of the same size satisfy a predicate. + Zero elements may be skipped on sparse data structures if allowed (default). + + + + + Returns a Vector containing the same values of . + + This method is included for completeness. + The vector to get the values from. + A vector containing the same values as . + If is . + + + + Returns a Vector containing the negated values of . + + The vector to get the values from. + A vector containing the negated values as . + If is . + + + + Adds two Vectors together and returns the results. + + One of the vectors to add. + The other vector to add. + The result of the addition. + If and are not the same size. + If or is . + + + + Adds a scalar to each element of a vector. + + The vector to add to. + The scalar value to add. + The result of the addition. + If is . + + + + Adds a scalar to each element of a vector. + + The scalar value to add. + The vector to add to. + The result of the addition. + If is . + + + + Subtracts two Vectors and returns the results. + + The vector to subtract from. + The vector to subtract. + The result of the subtraction. + If and are not the same size. + If or is . + + + + Subtracts a scalar from each element of a vector. + + The vector to subtract from. + The scalar value to subtract. + The result of the subtraction. + If is . + + + + Subtracts each element of a vector from a scalar. + + The scalar value to subtract from. + The vector to subtract. + The result of the subtraction. + If is . + + + + Multiplies a vector with a scalar. + + The vector to scale. + The scalar value. + The result of the multiplication. + If is . + + + + Multiplies a vector with a scalar. + + The scalar value. + The vector to scale. + The result of the multiplication. + If is . + + + + Computes the dot product between two Vectors. + + The left row vector. + The right column vector. + The dot product between the two vectors. + If and are not the same size. + If or is . + + + + Divides a scalar with a vector. + + The scalar to divide. + The vector. + The result of the division. + If is . + + + + Divides a vector with a scalar. + + The vector to divide. + The scalar value. + The result of the division. + If is . + + + + Pointwise divides two Vectors. + + The vector to divide. + The other vector. + The result of the division. + If and are not the same size. + If is . + + + + Computes the remainder (% operator), where the result has the sign of the dividend, + of each element of the vector of the given divisor. + + The vector whose elements we want to compute the remainder of. + The divisor to use. + If is . + + + + Computes the remainder (% operator), where the result has the sign of the dividend, + of the given dividend of each element of the vector. + + The dividend we want to compute the remainder of. + The vector whose elements we want to use as divisor. + If is . + + + + Computes the pointwise remainder (% operator), where the result has the sign of the dividend, + of each element of two vectors. + + The vector whose elements we want to compute the remainder of. + The divisor to use. + If and are not the same size. + If is . + + + + Computes the sqrt of a vector pointwise + + The input vector + + + + + Computes the exponential of a vector pointwise + + The input vector + + + + + Computes the log of a vector pointwise + + The input vector + + + + + Computes the log10 of a vector pointwise + + The input vector + + + + + Computes the sin of a vector pointwise + + The input vector + + + + + Computes the cos of a vector pointwise + + The input vector + + + + + Computes the tan of a vector pointwise + + The input vector + + + + + Computes the asin of a vector pointwise + + The input vector + + + + + Computes the acos of a vector pointwise + + The input vector + + + + + Computes the atan of a vector pointwise + + The input vector + + + + + Computes the sinh of a vector pointwise + + The input vector + + + + + Computes the cosh of a vector pointwise + + The input vector + + + + + Computes the tanh of a vector pointwise + + The input vector + + + + + Computes the absolute value of a vector pointwise + + The input vector + + + + + Computes the floor of a vector pointwise + + The input vector + + + + + Computes the ceiling of a vector pointwise + + The input vector + + + + + Computes the rounded value of a vector pointwise + + The input vector + + + + + Converts a vector to single precision. + + + + + Converts a vector to double precision. + + + + + Converts a vector to single precision complex numbers. + + + + + Converts a vector to double precision complex numbers. + + + + + Gets a single precision complex vector with the real parts from the given vector. + + + + + Gets a double precision complex vector with the real parts from the given vector. + + + + + Gets a real vector representing the real parts of a complex vector. + + + + + Gets a real vector representing the real parts of a complex vector. + + + + + Gets a real vector representing the imaginary parts of a complex vector. + + + + + Gets a real vector representing the imaginary parts of a complex vector. + + + + + Find the model parameters β such that X*β with predictor X becomes as close to response Y as possible, with least squares residuals. + + Predictor matrix X + Response vector Y + The direct method to be used to compute the regression. + Best fitting vector for model parameters β + + + + Find the model parameters β such that X*β with predictor X becomes as close to response Y as possible, with least squares residuals. + + Predictor matrix X + Response matrix Y + The direct method to be used to compute the regression. + Best fitting vector for model parameters β + + + + Find the model parameters β such that their linear combination with all predictor-arrays in X become as close to their response in Y as possible, with least squares residuals. + + List of predictor-arrays. + List of responses + True if an intercept should be added as first artificial predictor value. Default = false. + The direct method to be used to compute the regression. + Best fitting list of model parameters β for each element in the predictor-arrays. + + + + Find the model parameters β such that their linear combination with all predictor-arrays in X become as close to their response in Y as possible, with least squares residuals. + Uses the cholesky decomposition of the normal equations. + + Sequence of predictor-arrays and their response. + True if an intercept should be added as first artificial predictor value. Default = false. + The direct method to be used to compute the regression. + Best fitting list of model parameters β for each element in the predictor-arrays. + + + + Find the model parameters β such that X*β with predictor X becomes as close to response Y as possible, with least squares residuals. + Uses the cholesky decomposition of the normal equations. + + Predictor matrix X + Response vector Y + Best fitting vector for model parameters β + + + + Find the model parameters β such that X*β with predictor X becomes as close to response Y as possible, with least squares residuals. + Uses the cholesky decomposition of the normal equations. + + Predictor matrix X + Response matrix Y + Best fitting vector for model parameters β + + + + Find the model parameters β such that their linear combination with all predictor-arrays in X become as close to their response in Y as possible, with least squares residuals. + Uses the cholesky decomposition of the normal equations. + + List of predictor-arrays. + List of responses + True if an intercept should be added as first artificial predictor value. Default = false. + Best fitting list of model parameters β for each element in the predictor-arrays. + + + + Find the model parameters β such that their linear combination with all predictor-arrays in X become as close to their response in Y as possible, with least squares residuals. + Uses the cholesky decomposition of the normal equations. + + Sequence of predictor-arrays and their response. + True if an intercept should be added as first artificial predictor value. Default = false. + Best fitting list of model parameters β for each element in the predictor-arrays. + + + + Find the model parameters β such that their linear combination with all predictor-arrays in X become as close to their response in Y as possible, with least squares residuals. + Uses the cholesky decomposition of the normal equations. + + Sequence of predictor-arrays and their response. + True if an intercept should be added as first artificial predictor value. Default = false. + Best fitting list of model parameters β for each element in the predictor-arrays. + + + + Find the model parameters β such that X*β with predictor X becomes as close to response Y as possible, with least squares residuals. + Uses an orthogonal decomposition and is therefore more numerically stable than the normal equations but also slower. + + Predictor matrix X + Response vector Y + Best fitting vector for model parameters β + + + + Find the model parameters β such that X*β with predictor X becomes as close to response Y as possible, with least squares residuals. + Uses an orthogonal decomposition and is therefore more numerically stable than the normal equations but also slower. + + Predictor matrix X + Response matrix Y + Best fitting vector for model parameters β + + + + Find the model parameters β such that their linear combination with all predictor-arrays in X become as close to their response in Y as possible, with least squares residuals. + Uses an orthogonal decomposition and is therefore more numerically stable than the normal equations but also slower. + + List of predictor-arrays. + List of responses + True if an intercept should be added as first artificial predictor value. Default = false. + Best fitting list of model parameters β for each element in the predictor-arrays. + + + + Find the model parameters β such that their linear combination with all predictor-arrays in X become as close to their response in Y as possible, with least squares residuals. + Uses an orthogonal decomposition and is therefore more numerically stable than the normal equations but also slower. + + Sequence of predictor-arrays and their response. + True if an intercept should be added as first artificial predictor value. Default = false. + Best fitting list of model parameters β for each element in the predictor-arrays. + + + + Find the model parameters β such that their linear combination with all predictor-arrays in X become as close to their response in Y as possible, with least squares residuals. + Uses an orthogonal decomposition and is therefore more numerically stable than the normal equations but also slower. + + Sequence of predictor-arrays and their response. + True if an intercept should be added as first artificial predictor value. Default = false. + Best fitting list of model parameters β for each element in the predictor-arrays. + + + + Find the model parameters β such that X*β with predictor X becomes as close to response Y as possible, with least squares residuals. + Uses a singular value decomposition and is therefore more numerically stable (especially if ill-conditioned) than the normal equations or QR but also slower. + + Predictor matrix X + Response vector Y + Best fitting vector for model parameters β + + + + Find the model parameters β such that X*β with predictor X becomes as close to response Y as possible, with least squares residuals. + Uses a singular value decomposition and is therefore more numerically stable (especially if ill-conditioned) than the normal equations or QR but also slower. + + Predictor matrix X + Response matrix Y + Best fitting vector for model parameters β + + + + Find the model parameters β such that their linear combination with all predictor-arrays in X become as close to their response in Y as possible, with least squares residuals. + Uses a singular value decomposition and is therefore more numerically stable (especially if ill-conditioned) than the normal equations or QR but also slower. + + List of predictor-arrays. + List of responses + True if an intercept should be added as first artificial predictor value. Default = false. + Best fitting list of model parameters β for each element in the predictor-arrays. + + + + Find the model parameters β such that their linear combination with all predictor-arrays in X become as close to their response in Y as possible, with least squares residuals. + Uses a singular value decomposition and is therefore more numerically stable (especially if ill-conditioned) than the normal equations or QR but also slower. + + Sequence of predictor-arrays and their response. + True if an intercept should be added as first artificial predictor value. Default = false. + Best fitting list of model parameters β for each element in the predictor-arrays. + + + + Find the model parameters β such that their linear combination with all predictor-arrays in X become as close to their response in Y as possible, with least squares residuals. + Uses a singular value decomposition and is therefore more numerically stable (especially if ill-conditioned) than the normal equations or QR but also slower. + + Sequence of predictor-arrays and their response. + True if an intercept should be added as first artificial predictor value. Default = false. + Best fitting list of model parameters β for each element in the predictor-arrays. + + + + Least-Squares fitting the points (x,y) to a line y : x -> a+b*x, + returning its best fitting parameters as (a, b) tuple, + where a is the intercept and b the slope. + + Predictor (independent) + Response (dependent) + + + + Least-Squares fitting the points (x,y) to a line y : x -> a+b*x, + returning its best fitting parameters as (a, b) tuple, + where a is the intercept and b the slope. + + Predictor-Response samples as tuples + + + + Least-Squares fitting the points (x,y) to a line y : x -> a+b*x, + returning its best fitting parameters as (a, b) tuple, + where a is the intercept and b the slope. + + Predictor-Response samples as tuples + + + + Least-Squares fitting the points (x,y) to a line y : x -> b*x, + returning its best fitting parameter b, + where the intercept is zero and b the slope. + + Predictor (independent) + Response (dependent) + + + + Least-Squares fitting the points (x,y) to a line y : x -> b*x, + returning its best fitting parameter b, + where the intercept is zero and b the slope. + + Predictor-Response samples as tuples + + + + Weighted Linear Regression using normal equations. + + Predictor matrix X + Response vector Y + Weight matrix W, usually diagonal with an entry for each predictor (row). + + + + Weighted Linear Regression using normal equations. + + Predictor matrix X + Response matrix Y + Weight matrix W, usually diagonal with an entry for each predictor (row). + + + + Weighted Linear Regression using normal equations. + + Predictor matrix X + Response vector Y + Weight matrix W, usually diagonal with an entry for each predictor (row). + True if an intercept should be added as first artificial predictor value. Default = false. + + + + Weighted Linear Regression using normal equations. + + List of sample vectors (predictor) together with their response. + List of weights, one for each sample. + True if an intercept should be added as first artificial predictor value. Default = false. + + + + Weighted Linear Regression using normal equations. + + List of sample vectors (predictor) together with their response. + List of weights, one for each sample. + True if an intercept should be added as first artificial predictor value. Default = false. + + + + Locally-Weighted Linear Regression using normal equations. + + + + + Locally-Weighted Linear Regression using normal equations. + + + + + First Order AB method(same as Forward Euler) + + Initial value + Start Time + End Time + Size of output array(the larger, the finer) + ode model + approximation with size N + + + + Second Order AB Method + + Initial value 1 + Start Time + End Time + Size of output array(the larger, the finer) + ode model + approximation with size N + + + + Third Order AB Method + + Initial value 1 + Start Time + End Time + Size of output array(the larger, the finer) + ode model + approximation with size N + + + + Fourth Order AB Method + + Initial value 1 + Start Time + End Time + Size of output array(the larger, the finer) + ode model + approximation with size N + + + + ODE Solver Algorithms + + + + + Second Order Runge-Kutta method + + initial value + start time + end time + Size of output array(the larger, the finer) + ode function + approximations + + + + Fourth Order Runge-Kutta method + + initial value + start time + end time + Size of output array(the larger, the finer) + ode function + approximations + + + + Second Order Runge-Kutta to solve ODE SYSTEM + + initial vector + start time + end time + Size of output array(the larger, the finer) + ode function + approximations + + + + Fourth Order Runge-Kutta to solve ODE SYSTEM + + initial vector + start time + end time + Size of output array(the larger, the finer) + ode function + approximations + + + + Broyden–Fletcher–Goldfarb–Shanno Bounded (BFGS-B) algorithm is an iterative method for solving box-constrained nonlinear optimization problems + http://www.ece.northwestern.edu/~nocedal/PSfiles/limited.ps.gz + + + + + Find the minimum of the objective function given lower and upper bounds + + The objective function, must support a gradient + The lower bound + The upper bound + The initial guess + The MinimizationResult which contains the minimum and the ExitCondition + + + + Broyden–Fletcher–Goldfarb–Shanno (BFGS) algorithm is an iterative method for solving unconstrained nonlinear optimization problems + + + + + Creates BFGS minimizer + + The gradient tolerance + The parameter tolerance + The function progress tolerance + The maximum number of iterations + + + + Find the minimum of the objective function given lower and upper bounds + + The objective function, must support a gradient + The initial guess + The MinimizationResult which contains the minimum and the ExitCondition + + + + + Creates a base class for BFGS minimization + + + + + Broyden-Fletcher-Goldfarb-Shanno solver for finding function minima + See http://en.wikipedia.org/wiki/Broyden%E2%80%93Fletcher%E2%80%93Goldfarb%E2%80%93Shanno_algorithm + Inspired by implementation: https://github.com/PatWie/CppNumericalSolvers/blob/master/src/BfgsSolver.cpp + + + + + Finds a minimum of a function by the BFGS quasi-Newton method + This uses the function and it's gradient (partial derivatives in each direction) and approximates the Hessian + + An initial guess + Evaluates the function at a point + Evaluates the gradient of the function at a point + The minimum found + + + + Objective function with a frozen evaluation that must not be changed from the outside. + + + + Create a new unevaluated and independent copy of this objective function + + + + Objective function with a mutable evaluation. + + + + Create a new independent copy of this objective function, evaluated at the same point. + + + + Get the y-values of the observations. + + + + + Get the values of the weights for the observations. + + + + + Get the y-values of the fitted model that correspond to the independent values. + + + + + Get the values of the parameters. + + + + + Get the residual sum of squares. + + + + + Get the Gradient vector. G = J'(y - f(x; p)) + + + + + Get the approximated Hessian matrix. H = J'J + + + + + Get the number of calls to function. + + + + + Get the number of calls to jacobian. + + + + + Get the degree of freedom. + + + + + The scale factor for initial mu + + + + + Non-linear least square fitting by the Levenberg-Marduardt algorithm. + + The objective function, including model, observations, and parameter bounds. + The initial guess values. + The initial damping parameter of mu. + The stopping threshold for infinity norm of the gradient vector. + The stopping threshold for L2 norm of the change of parameters. + The stopping threshold for L2 norm of the residuals. + The max iterations. + The result of the Levenberg-Marquardt minimization + + + + Limited Memory version of Broyden–Fletcher–Goldfarb–Shanno (BFGS) algorithm + + + + + + Creates L-BFGS minimizer + + Numbers of gradients and steps to store. + + + + Find the minimum of the objective function given lower and upper bounds + + The objective function, must support a gradient + The initial guess + The MinimizationResult which contains the minimum and the ExitCondition + + + + Search for a step size alpha that satisfies the weak Wolfe conditions. The weak Wolfe + Conditions are + i) Armijo Rule: f(x_k + alpha_k p_k) <= f(x_k) + c1 alpha_k p_k^T g(x_k) + ii) Curvature Condition: p_k^T g(x_k + alpha_k p_k) >= c2 p_k^T g(x_k) + where g(x) is the gradient of f(x), 0 < c1 < c2 < 1. + + Implementation is based on http://www.math.washington.edu/~burke/crs/408/lectures/L9-weak-Wolfe.pdf + + references: + http://en.wikipedia.org/wiki/Wolfe_conditions + http://www.math.washington.edu/~burke/crs/408/lectures/L9-weak-Wolfe.pdf + + + + Implemented following http://www.math.washington.edu/~burke/crs/408/lectures/L9-weak-Wolfe.pdf + The objective function being optimized, evaluated at the starting point of the search + Search direction + Initial size of the step in the search direction + + + + The objective function being optimized, evaluated at the starting point of the search + Search direction + Initial size of the step in the search direction + The upper bound + + + + Creates a base class for minimization + + The gradient tolerance + The parameter tolerance + The function progress tolerance + The maximum number of iterations + + + + Class implementing the Nelder-Mead simplex algorithm, used to find a minima when no gradient is available. + Called fminsearch() in Matlab. A description of the algorithm can be found at + http://se.mathworks.com/help/matlab/math/optimizing-nonlinear-functions.html#bsgpq6p-11 + or + https://en.wikipedia.org/wiki/Nelder%E2%80%93Mead_method + + + + + Finds the minimum of the objective function without an initial perturbation, the default values used + by fminsearch() in Matlab are used instead + http://se.mathworks.com/help/matlab/math/optimizing-nonlinear-functions.html#bsgpq6p-11 + + The objective function, no gradient or hessian needed + The initial guess + The minimum point + + + + Finds the minimum of the objective function with an initial perturbation + + The objective function, no gradient or hessian needed + The initial guess + The initial perturbation + The minimum point + + + + Finds the minimum of the objective function without an initial perturbation, the default values used + by fminsearch() in Matlab are used instead + http://se.mathworks.com/help/matlab/math/optimizing-nonlinear-functions.html#bsgpq6p-11 + + The objective function, no gradient or hessian needed + The initial guess + The minimum point + + + + Finds the minimum of the objective function with an initial perturbation + + The objective function, no gradient or hessian needed + The initial guess + The initial perturbation + The minimum point + + + + Evaluate the objective function at each vertex to create a corresponding + list of error values for each vertex + + + + + + + + Check whether the points in the error profile have so little range that we + consider ourselves to have converged + + + + + + + + + Examine all error values to determine the ErrorProfile + + + + + + + Construct an initial simplex, given starting guesses for the constants, and + initial step sizes for each dimension + + + + + + + Test a scaling operation of the high point, and replace it if it is an improvement + + + + + + + + + + + Contract the simplex uniformly around the lowest point + + + + + + + + + Compute the centroid of all points except the worst + + + + + + + + The value of the constant + + + + + Returns the best fit parameters. + + + + + Returns the standard errors of the corresponding parameters + + + + + Returns the y-values of the fitted model that correspond to the independent values. + + + + + Returns the covariance matrix at minimizing point. + + + + + Returns the correlation matrix at minimizing point. + + + + + The stopping threshold for the function value or L2 norm of the residuals. + + + + + The stopping threshold for L2 norm of the change of the parameters. + + + + + The stopping threshold for infinity norm of the gradient. + + + + + The maximum number of iterations. + + + + + The lower bound of the parameters. + + + + + The upper bound of the parameters. + + + + + The scale factors for the parameters. + + + + + Objective function where neither Gradient nor Hessian is available. + + + + + Objective function where the Gradient is available. Greedy evaluation. + + + + + Objective function where the Gradient is available. Lazy evaluation. + + + + + Objective function where the Hessian is available. Greedy evaluation. + + + + + Objective function where the Hessian is available. Lazy evaluation. + + + + + Objective function where both Gradient and Hessian are available. Greedy evaluation. + + + + + Objective function where both Gradient and Hessian are available. Lazy evaluation. + + + + + Objective function where neither first nor second derivative is available. + + + + + Objective function where the first derivative is available. + + + + + Objective function where the first and second derivatives are available. + + + + + objective model with a user supplied jacobian for non-linear least squares regression. + + + + + Objective model for non-linear least squares regression. + + + + + Objective model with a user supplied jacobian for non-linear least squares regression. + + + + + Objective model for non-linear least squares regression. + + + + + Objective function with a user supplied jacobian for nonlinear least squares regression. + + + + + Objective function for nonlinear least squares regression. + The numerical jacobian with accuracy order is used. + + + + + Adapts an objective function with only value implemented + to provide a gradient as well. Gradient calculation is + done using the finite difference method, specifically + forward differences. + + For each gradient computed, the algorithm requires an + additional number of function evaluations equal to the + functions's number of input parameters. + + + + + Set or get the values of the independent variable. + + + + + Set or get the values of the observations. + + + + + Set or get the values of the weights for the observations. + + + + + Get whether parameters are fixed or free. + + + + + Get the number of observations. + + + + + Get the number of unknown parameters. + + + + + Get the degree of freedom + + + + + Get the number of calls to function. + + + + + Get the number of calls to jacobian. + + + + + Set or get the values of the parameters. + + + + + Get the y-values of the fitted model that correspond to the independent values. + + + + + Get the residual sum of squares. + + + + + Get the Gradient vector of x and p. + + + + + Get the Hessian matrix of x and p, J'WJ + + + + + Set observed data to fit. + + + + + Set parameters and bounds. + + The initial values of parameters. + The list to the parameters fix or free. + + + + Non-linear least square fitting by the trust region dogleg algorithm. + + + + + The trust region subproblem. + + + + + The stopping threshold for the trust region radius. + + + + + Non-linear least square fitting by the trust-region algorithm. + + The objective model, including function, jacobian, observations, and parameter bounds. + The subproblem + The initial guess values. + The stopping threshold for L2 norm of the residuals. + The stopping threshold for infinity norm of the gradient vector. + The stopping threshold for L2 norm of the change of parameters. + The stopping threshold for trust region radius + The max iterations. + + + + + Non-linear least square fitting by the trust region Newton-Conjugate-Gradient algorithm. + + + + + Class to represent a permutation for a subset of the natural numbers. + + + + + Entry _indices[i] represents the location to which i is permuted to. + + + + + Initializes a new instance of the Permutation class. + + An array which represents where each integer is permuted too: indices[i] represents that integer i + is permuted to location indices[i]. + + + + Gets the number of elements this permutation is over. + + + + + Computes where permutes too. + + The index to permute from. + The index which is permuted to. + + + + Computes the inverse of the permutation. + + The inverse of the permutation. + + + + Construct an array from a sequence of inversions. + + + From wikipedia: the permutation 12043 has the inversions (0,2), (1,2) and (3,4). This would be + encoded using the array [22244]. + + The set of inversions to construct the permutation from. + A permutation generated from a sequence of inversions. + + + + Construct a sequence of inversions from the permutation. + + + From wikipedia: the permutation 12043 has the inversions (0,2), (1,2) and (3,4). This would be + encoded using the array [22244]. + + A sequence of inversions. + + + + Checks whether the array represents a proper permutation. + + An array which represents where each integer is permuted too: indices[i] represents that integer i + is permuted to location indices[i]. + True if represents a proper permutation, false otherwise. + + + + A single-variable polynomial with real-valued coefficients and non-negative exponents. + + + + + The coefficients of the polynomial in a + + + + + Only needed for the ToString method + + + + + Degree of the polynomial, i.e. the largest monomial exponent. For example, the degree of y=x^2+x^5 is 5, for y=3 it is 0. + The null-polynomial returns degree -1 because the correct degree, negative infinity, cannot be represented by integers. + + + + + Create a zero-polynomial with a coefficient array of the given length. + An array of length N can support polynomials of a degree of at most N-1. + + Length of the coefficient array + + + + Create a zero-polynomial + + + + + Create a constant polynomial. + Example: 3.0 -> "p : x -> 3.0" + + The coefficient of the "x^0" monomial. + + + + Create a polynomial with the provided coefficients (in ascending order, where the index matches the exponent). + Example: {5, 0, 2} -> "p : x -> 5 + 0 x^1 + 2 x^2". + + Polynomial coefficients as array + + + + Create a polynomial with the provided coefficients (in ascending order, where the index matches the exponent). + Example: {5, 0, 2} -> "p : x -> 5 + 0 x^1 + 2 x^2". + + Polynomial coefficients as enumerable + + + + Least-Squares fitting the points (x,y) to a k-order polynomial y : x -> p0 + p1*x + p2*x^2 + ... + pk*x^k + + + + + Evaluate a polynomial at point x. + Coefficients are ordered ascending by power with power k at index k. + Example: coefficients [3,-1,2] represent y=2x^2-x+3. + + The location where to evaluate the polynomial at. + The coefficients of the polynomial, coefficient for power k at index k. + + is a null reference. + + + + + Evaluate a polynomial at point x. + Coefficients are ordered ascending by power with power k at index k. + Example: coefficients [3,-1,2] represent y=2x^2-x+3. + + The location where to evaluate the polynomial at. + The coefficients of the polynomial, coefficient for power k at index k. + + is a null reference. + + + + + Evaluate a polynomial at point x. + Coefficients are ordered ascending by power with power k at index k. + Example: coefficients [3,-1,2] represent y=2x^2-x+3. + + The location where to evaluate the polynomial at. + The coefficients of the polynomial, coefficient for power k at index k. + + is a null reference. + + + + + Evaluate a polynomial at point x. + + The location where to evaluate the polynomial at. + + + + Evaluate a polynomial at point x. + + The location where to evaluate the polynomial at. + + + + Evaluate a polynomial at points z. + + The locations where to evaluate the polynomial at. + + + + Evaluate a polynomial at points z. + + The locations where to evaluate the polynomial at. + + + + Calculates the complex roots of the Polynomial by eigenvalue decomposition + + a vector of complex numbers with the roots + + + + Get the eigenvalue matrix A of this polynomial such that eig(A) = roots of this polynomial. + + Eigenvalue matrix A + This matrix is similar to the companion matrix of this polynomial, in such a way, that it's transpose is the columnflip of the companion matrix + + + + Addition of two Polynomials (point-wise). + + Left Polynomial + Right Polynomial + Resulting Polynomial + + + + Addition of a polynomial and a scalar. + + + + + Subtraction of two Polynomials (point-wise). + + Left Polynomial + Right Polynomial + Resulting Polynomial + + + + Addition of a scalar from a polynomial. + + + + + Addition of a polynomial from a scalar. + + + + + Negation of a polynomial. + + + + + Multiplies a polynomial by a polynomial (convolution) + + Left polynomial + Right polynomial + Resulting Polynomial + + or is a null reference. + + + + + Scales a polynomial by a scalar + + Polynomial + Scalar value + Resulting Polynomial + + + + Scales a polynomial by division by a scalar + + Polynomial + Scalar value + Resulting Polynomial + + + + Euclidean long division of two polynomials, returning the quotient q and remainder r of the two polynomials a and b such that a = q*b + r + + Left polynomial + Right polynomial + A tuple holding quotient in first and remainder in second + + + + Point-wise division of two Polynomials + + Left Polynomial + Right Polynomial + Resulting Polynomial + + + + Point-wise multiplication of two Polynomials + + Left Polynomial + Right Polynomial + Resulting Polynomial + + + + Division of two polynomials returning the quotient-with-remainder of the two polynomials given + + Right polynomial + A tuple holding quotient in first and remainder in second + + + + Addition of two Polynomials (piecewise) + + Left polynomial + Right polynomial + Resulting Polynomial + + + + adds a scalar to a polynomial. + + Polynomial + Scalar value + Resulting Polynomial + + + + adds a scalar to a polynomial. + + Scalar value + Polynomial + Resulting Polynomial + + + + Subtraction of two polynomial. + + Left polynomial + Right polynomial + Resulting Polynomial + + + + Subtracts a scalar from a polynomial. + + Polynomial + Scalar value + Resulting Polynomial + + + + Subtracts a polynomial from a scalar. + + Scalar value + Polynomial + Resulting Polynomial + + + + Negates a polynomial. + + Polynomial + Resulting Polynomial + + + + Multiplies a polynomial by a polynomial (convolution). + + Left polynomial + Right polynomial + resulting Polynomial + + + + Multiplies a polynomial by a scalar. + + Polynomial + Scalar value + Resulting Polynomial + + + + Multiplies a polynomial by a scalar. + + Scalar value + Polynomial + Resulting Polynomial + + + + Divides a polynomial by scalar value. + + Polynomial + Scalar value + Resulting Polynomial + + + + Format the polynomial in ascending order, e.g. "4.3 + 2.0x^2 - x^3". + + + + + Format the polynomial in descending order, e.g. "x^3 + 2.0x^2 - 4.3". + + + + + Format the polynomial in ascending order, e.g. "4.3 + 2.0x^2 - x^3". + + + + + Format the polynomial in descending order, e.g. "x^3 + 2.0x^2 - 4.3". + + + + + Format the polynomial in ascending order, e.g. "4.3 + 2.0x^2 - x^3". + + + + + Format the polynomial in descending order, e.g. "x^3 + 2.0x^2 - 4.3". + + + + + Format the polynomial in ascending order, e.g. "4.3 + 2.0x^2 - x^3". + + + + + Format the polynomial in descending order, e.g. "x^3 + 2.0x^2 - 4.3". + + + + + Creates a new object that is a copy of the current instance. + + + A new object that is a copy of this instance. + + + + + Utilities for working with floating point numbers. + + + + Useful links: + + + http://docs.sun.com/source/806-3568/ncg_goldberg.html#689 - What every computer scientist should know about floating-point arithmetic + + + http://en.wikipedia.org/wiki/Machine_epsilon - Gives the definition of machine epsilon + + + + + + + + Compares two doubles and determines which double is bigger. + a < b -> -1; a ~= b (almost equal according to parameter) -> 0; a > b -> +1. + + The first value. + The second value. + The absolute accuracy required for being almost equal. + + + + Compares two doubles and determines which double is bigger. + a < b -> -1; a ~= b (almost equal according to parameter) -> 0; a > b -> +1. + + The first value. + The second value. + The number of decimal places on which the values must be compared. Must be 1 or larger. + + + + Compares two doubles and determines which double is bigger. + a < b -> -1; a ~= b (almost equal according to parameter) -> 0; a > b -> +1. + + The first value. + The second value. + The relative accuracy required for being almost equal. + + + + Compares two doubles and determines which double is bigger. + a < b -> -1; a ~= b (almost equal according to parameter) -> 0; a > b -> +1. + + The first value. + The second value. + The number of decimal places on which the values must be compared. Must be 1 or larger. + + + + Compares two doubles and determines which double is bigger. + a < b -> -1; a ~= b (almost equal according to parameter) -> 0; a > b -> +1. + + The first value. + The second value. + The maximum error in terms of Units in Last Place (ulps), i.e. the maximum number of decimals that may be different. Must be 1 or larger. + + + + Compares two doubles and determines if the first value is larger than the second + value to within the specified number of decimal places or not. + + + + The values are equal if the difference between the two numbers is smaller than 10^(-numberOfDecimalPlaces). We divide by + two so that we have half the range on each side of the numbers, e.g. if == 2, then 0.01 will equal between + 0.005 and 0.015, but not 0.02 and not 0.00 + + + The first value. + The second value. + The number of decimal places. + true if the first value is larger than the second value; otherwise false. + + + + Compares two doubles and determines if the first value is larger than the second + value to within the specified number of decimal places or not. + + + + The values are equal if the difference between the two numbers is smaller than 10^(-numberOfDecimalPlaces). We divide by + two so that we have half the range on each side of the numbers, e.g. if == 2, then 0.01 will equal between + 0.005 and 0.015, but not 0.02 and not 0.00 + + + The first value. + The second value. + The number of decimal places. + true if the first value is larger than the second value; otherwise false. + + + + Compares two doubles and determines if the first value is larger than the second + value to within the specified number of decimal places or not. + + The first value. + The second value. + The absolute accuracy required for being almost equal. + true if the first value is larger than the second value; otherwise false. + + + + Compares two doubles and determines if the first value is larger than the second + value to within the specified number of decimal places or not. + + The first value. + The second value. + The absolute accuracy required for being almost equal. + true if the first value is larger than the second value; otherwise false. + + + + Compares two doubles and determines if the first value is larger than the second + value to within the specified number of decimal places or not. + + + + The values are equal if the difference between the two numbers is smaller than 10^(-numberOfDecimalPlaces). We divide by + two so that we have half the range on each side of the numbers, e.g. if == 2, then 0.01 will equal between + 0.005 and 0.015, but not 0.02 and not 0.00 + + + The first value. + The second value. + The number of decimal places. + true if the first value is larger than the second value; otherwise false. + + + + Compares two doubles and determines if the first value is larger than the second + value to within the specified number of decimal places or not. + + + + The values are equal if the difference between the two numbers is smaller than 10^(-numberOfDecimalPlaces). We divide by + two so that we have half the range on each side of the numbers, e.g. if == 2, then 0.01 will equal between + 0.005 and 0.015, but not 0.02 and not 0.00 + + + The first value. + The second value. + The number of decimal places. + true if the first value is larger than the second value; otherwise false. + + + + Compares two doubles and determines if the first value is larger than the second + value to within the specified number of decimal places or not. + + The first value. + The second value. + The relative accuracy required for being almost equal. + true if the first value is larger than the second value; otherwise false. + + + + Compares two doubles and determines if the first value is larger than the second + value to within the specified number of decimal places or not. + + The first value. + The second value. + The relative accuracy required for being almost equal. + true if the first value is larger than the second value; otherwise false. + + + + Compares two doubles and determines if the first value is larger than the second + value to within the tolerance or not. Equality comparison is based on the binary representation. + + The first value. + The second value. + The maximum number of floating point values for which the two values are considered equal. Must be 1 or larger. + true if the first value is larger than the second value; otherwise false. + + + + Compares two doubles and determines if the first value is larger than the second + value to within the tolerance or not. Equality comparison is based on the binary representation. + + The first value. + The second value. + The maximum number of floating point values for which the two values are considered equal. Must be 1 or larger. + true if the first value is larger than the second value; otherwise false. + + + + Compares two doubles and determines if the first value is smaller than the second + value to within the specified number of decimal places or not. + + + + The values are equal if the difference between the two numbers is smaller than 10^(-numberOfDecimalPlaces). We divide by + two so that we have half the range on each side of thg. if == 2, then 0.01 will equal between + 0.005 and 0.015, but not 0.02 and not 0.00 + + + The first value. + The second value. + The number of decimal places. + true if the first value is smaller than the second value; otherwise false. + + + + Compares two doubles and determines if the first value is smaller than the second + value to within the specified number of decimal places or not. + + + + The values are equal if the difference between the two numbers is smaller than 10^(-numberOfDecimalPlaces). We divide by + two so that we have half the range on each side of thg. if == 2, then 0.01 will equal between + 0.005 and 0.015, but not 0.02 and not 0.00 + + + The first value. + The second value. + The number of decimal places. + true if the first value is smaller than the second value; otherwise false. + + + + Compares two doubles and determines if the first value is smaller than the second + value to within the specified number of decimal places or not. + + The first value. + The second value. + The absolute accuracy required for being almost equal. + true if the first value is smaller than the second value; otherwise false. + + + + Compares two doubles and determines if the first value is smaller than the second + value to within the specified number of decimal places or not. + + The first value. + The second value. + The absolute accuracy required for being almost equal. + true if the first value is smaller than the second value; otherwise false. + + + + Compares two doubles and determines if the first value is smaller than the second + value to within the specified number of decimal places or not. + + The first value. + The second value. + The number of decimal places. + true if the first value is smaller than the second value; otherwise false. + + + + Compares two doubles and determines if the first value is smaller than the second + value to within the specified number of decimal places or not. + + The first value. + The second value. + The number of decimal places. + true if the first value is smaller than the second value; otherwise false. + + + + Compares two doubles and determines if the first value is smaller than the second + value to within the specified number of decimal places or not. + + The first value. + The second value. + The relative accuracy required for being almost equal. + true if the first value is smaller than the second value; otherwise false. + + + + Compares two doubles and determines if the first value is smaller than the second + value to within the specified number of decimal places or not. + + The first value. + The second value. + The relative accuracy required for being almost equal. + true if the first value is smaller than the second value; otherwise false. + + + + Compares two doubles and determines if the first value is smaller than the second + value to within the tolerance or not. Equality comparison is based on the binary representation. + + The first value. + The second value. + The maximum number of floating point values for which the two values are considered equal. Must be 1 or larger. + true if the first value is smaller than the second value; otherwise false. + + + + Compares two doubles and determines if the first value is smaller than the second + value to within the tolerance or not. Equality comparison is based on the binary representation. + + The first value. + The second value. + The maximum number of floating point values for which the two values are considered equal. Must be 1 or larger. + true if the first value is smaller than the second value; otherwise false. + + + + Checks if a given double values is finite, i.e. neither NaN nor inifnity + + The value to be checked fo finitenes. + + + + The number of binary digits used to represent the binary number for a double precision floating + point value. i.e. there are this many digits used to represent the + actual number, where in a number as: 0.134556 * 10^5 the digits are 0.134556 and the exponent is 5. + + + + + The number of binary digits used to represent the binary number for a single precision floating + point value. i.e. there are this many digits used to represent the + actual number, where in a number as: 0.134556 * 10^5 the digits are 0.134556 and the exponent is 5. + + + + + Standard epsilon, the maximum relative precision of IEEE 754 double-precision floating numbers (64 bit). + According to the definition of Prof. Demmel and used in LAPACK and Scilab. + + + + + Standard epsilon, the maximum relative precision of IEEE 754 double-precision floating numbers (64 bit). + According to the definition of Prof. Higham and used in the ISO C standard and MATLAB. + + + + + Standard epsilon, the maximum relative precision of IEEE 754 single-precision floating numbers (32 bit). + According to the definition of Prof. Demmel and used in LAPACK and Scilab. + + + + + Standard epsilon, the maximum relative precision of IEEE 754 single-precision floating numbers (32 bit). + According to the definition of Prof. Higham and used in the ISO C standard and MATLAB. + + + + + Actual double precision machine epsilon, the smallest number that can be subtracted from 1, yielding a results different than 1. + This is also known as unit roundoff error. According to the definition of Prof. Demmel. + On a standard machine this is equivalent to `DoublePrecision`. + + + + + Actual double precision machine epsilon, the smallest number that can be added to 1, yielding a results different than 1. + This is also known as unit roundoff error. According to the definition of Prof. Higham. + On a standard machine this is equivalent to `PositiveDoublePrecision`. + + + + + The number of significant decimal places of double-precision floating numbers (64 bit). + + + + + The number of significant decimal places of single-precision floating numbers (32 bit). + + + + + Value representing 10 * 2^(-53) = 1.11022302462516E-15 + + + + + Value representing 10 * 2^(-24) = 5.96046447753906E-07 + + + + + Returns the magnitude of the number. + + The value. + The magnitude of the number. + + + + Returns the magnitude of the number. + + The value. + The magnitude of the number. + + + + Returns the number divided by it's magnitude, effectively returning a number between -10 and 10. + + The value. + The value of the number. + + + + Returns a 'directional' long value. This is a long value which acts the same as a double, + e.g. a negative double value will return a negative double value starting at 0 and going + more negative as the double value gets more negative. + + The input double value. + A long value which is roughly the equivalent of the double value. + + + + Returns a 'directional' int value. This is a int value which acts the same as a float, + e.g. a negative float value will return a negative int value starting at 0 and going + more negative as the float value gets more negative. + + The input float value. + An int value which is roughly the equivalent of the double value. + + + + Increments a floating point number to the next bigger number representable by the data type. + + The value which needs to be incremented. + How many times the number should be incremented. + + The incrementation step length depends on the provided value. + Increment(double.MaxValue) will return positive infinity. + + The next larger floating point value. + + + + Decrements a floating point number to the next smaller number representable by the data type. + + The value which should be decremented. + How many times the number should be decremented. + + The decrementation step length depends on the provided value. + Decrement(double.MinValue) will return negative infinity. + + The next smaller floating point value. + + + + Forces small numbers near zero to zero, according to the specified absolute accuracy. + + The real number to coerce to zero, if it is almost zero. + The maximum count of numbers between the zero and the number . + + Zero if || is fewer than numbers from zero, otherwise. + + + + + Forces small numbers near zero to zero, according to the specified absolute accuracy. + + The real number to coerce to zero, if it is almost zero. + The maximum count of numbers between the zero and the number . + + Zero if || is fewer than numbers from zero, otherwise. + + + Thrown if is smaller than zero. + + + + + Forces small numbers near zero to zero, according to the specified absolute accuracy. + + The real number to coerce to zero, if it is almost zero. + The absolute threshold for to consider it as zero. + Zero if || is smaller than , otherwise. + + Thrown if is smaller than zero. + + + + + Forces small numbers near zero to zero. + + The real number to coerce to zero, if it is almost zero. + Zero if || is smaller than 2^(-53) = 1.11e-16, otherwise. + + + + Determines the range of floating point numbers that will match the specified value with the given tolerance. + + The value. + The ulps difference. + + Thrown if is smaller than zero. + + Tuple of the bottom and top range ends. + + + + Returns the floating point number that will match the value with the tolerance on the maximum size (i.e. the result is + always bigger than the value) + + The value. + The ulps difference. + The maximum floating point number which is larger than the given . + + + + Returns the floating point number that will match the value with the tolerance on the minimum size (i.e. the result is + always smaller than the value) + + The value. + The ulps difference. + The minimum floating point number which is smaller than the given . + + + + Determines the range of ulps that will match the specified value with the given tolerance. + + The value. + The relative difference. + + Thrown if is smaller than zero. + + + Thrown if is double.PositiveInfinity or double.NegativeInfinity. + + + Thrown if is double.NaN. + + + Tuple with the number of ULPS between the value and the value - relativeDifference as first, + and the number of ULPS between the value and the value + relativeDifference as second value. + + + + + Evaluates the count of numbers between two double numbers + + The first parameter. + The second parameter. + The second number is included in the number, thus two equal numbers evaluate to zero and two neighbor numbers evaluate to one. Therefore, what is returned is actually the count of numbers between plus 1. + The number of floating point values between and . + + Thrown if is double.PositiveInfinity or double.NegativeInfinity. + + + Thrown if is double.NaN. + + + Thrown if is double.PositiveInfinity or double.NegativeInfinity. + + + Thrown if is double.NaN. + + + + + Evaluates the minimum distance to the next distinguishable number near the argument value. + + The value used to determine the minimum distance. + + Relative Epsilon (positive double or NaN). + + Evaluates the negative epsilon. The more common positive epsilon is equal to two times this negative epsilon. + + + + + Evaluates the minimum distance to the next distinguishable number near the argument value. + + The value used to determine the minimum distance. + + Relative Epsilon (positive float or NaN). + + Evaluates the negative epsilon. The more common positive epsilon is equal to two times this negative epsilon. + + + + + Evaluates the minimum distance to the next distinguishable number near the argument value. + + The value used to determine the minimum distance. + Relative Epsilon (positive double or NaN) + Evaluates the positive epsilon. See also + + + + + Evaluates the minimum distance to the next distinguishable number near the argument value. + + The value used to determine the minimum distance. + Relative Epsilon (positive float or NaN) + Evaluates the positive epsilon. See also + + + + + Calculates the actual (negative) double precision machine epsilon - the smallest number that can be subtracted from 1, yielding a results different than 1. + This is also known as unit roundoff error. According to the definition of Prof. Demmel. + + Positive Machine epsilon + + + + Calculates the actual positive double precision machine epsilon - the smallest number that can be added to 1, yielding a results different than 1. + This is also known as unit roundoff error. According to the definition of Prof. Higham. + + Machine epsilon + + + + Round to a multiple of the provided positive basis. + + Number to be rounded. + The basis to whose multiples to round to. Must be positive. + + + + Round to a multiple of the provided positive basis. + + Number to be rounded. + The basis to whose multiples to round to. Must be positive. + + + + Round to a multiple of the provided positive basis. + + Number to be rounded. + The basis to whose multiples to round to. Must be positive. + + + + Round to a multiple of the provided positive basis. + + Number to be rounded. + The basis to whose powers to round to. Must be positive. + + + + Round to a multiple of the provided positive basis. + + Number to be rounded. + The basis to whose powers to round to. Must be positive. + + + + Round to the number closest to 10^(-decimals). Negative decimals to round within the integer part. + + Number to be rounded + If positive the number of decimals to round to. If negative the number of digits within the integer part to round, e.g. -3 will wound to the closes 1000. + To round 123456789 to hundreds Round(123456789, -2) = 123456800 + Rounded number + + + + Round to the number closest to 10^(-decimals). Negative decimals to round within the integer part. + + Number to be rounded + If positive the number of decimals to round to. If negative the number of digits within the integer part to round, e.g. -3 will wound to the closes 1000. + To round 123456789 to hundreds Round(123456789, -2) = 123456800 + Rounded number + + + + Round to the number closest to 10^(-decimals). Negative decimals to round within the integer part. + + Number to be rounded + If positive the number of decimals to round to. If negative the number of digits within the integer part to round, e.g. -3 will wound to the closes 1000. + To round 123456789 to hundreds Round(123456789, -2) = 123456800 + Rounded number + + + + Round to the number closest to 10^(-decimals). Negative decimals to round within the integer part. + + Number to be rounded + If positive the number of decimals to round to. If negative the number of digits within the integer part to round, e.g. -3 will wound to the closes 1000. + To round 123456789 to hundreds Round(123456789, -2) = 123456800 + Rounded number + + + + Round to the number closest to 10^(-decimals). Negative decimals to round within the integer part. + + Number to be rounded + If positive the number of decimals to round to. If negative the number of digits within the integer part to round, e.g. -3 will wound to the closes 1000. + To round 123456789 to hundreds Round(123456789, -2) = 123456800 + Rounded number + + + + Round to the number closest to 10^(-decimals). Negative decimals to round within the integer part. + + Number to be rounded + If positive the number of decimals to round to. If negative the number of digits within the integer part to round, e.g. -3 will wound to the closes 1000. + To round 123456789 to hundreds Round(123456789, -2) = 123456800 + Rounded number + + + + Round to the number closest to 10^(-decimals). Negative decimals to round within the integer part. + + Number to be rounded + If positive the number of decimals to round to. If negative the number of digits within the integer part to round, e.g. -3 will wound to the closes 1000. + To round 123456789 to hundreds Round(123456789, -2) = 123456800 + Rounded number + + + + Round to the number closest to 10^(-decimals). Negative decimals to round within the integer part. + + Number to be rounded + If positive the number of decimals to round to. If negative the number of digits within the integer part to round, e.g. -3 will wound to the closes 1000. + To round 123456789 to hundreds Round(123456789, -2) = 123456800 + Rounded number + + + + Round to the number closest to 10^(-decimals). Negative decimals to round within the integer part. + + Number to be rounded + If positive the number of decimals to round to. If negative the number of digits within the integer part to round, e.g. -3 will wound to the closes 1000. + To round 123456789 to hundreds Round(123456789, -2) = 123456800 + Rounded number + + + + Round to the number closest to 10^(-decimals). Negative decimals to round within the integer part. + + Number to be rounded + If positive the number of decimals to round to. If negative the number of digits within the integer part to round, e.g. -3 will wound to the closes 1000. + To round 123456789 to hundreds Round(123456789, -2) = 123456800 + Rounded number + + + + Compares two doubles and determines if they are equal + within the specified maximum absolute error. + + The norm of the first value (can be negative). + The norm of the second value (can be negative). + The norm of the difference of the two values (can be negative). + The absolute accuracy required for being almost equal. + True if both doubles are almost equal up to the specified maximum absolute error, false otherwise. + + + + Compares two doubles and determines if they are equal + within the specified maximum absolute error. + + The first value. + The second value. + The absolute accuracy required for being almost equal. + True if both doubles are almost equal up to the specified maximum absolute error, false otherwise. + + + + Compares two doubles and determines if they are equal + within the specified maximum error. + + The norm of the first value (can be negative). + The norm of the second value (can be negative). + The norm of the difference of the two values (can be negative). + The accuracy required for being almost equal. + True if both doubles are almost equal up to the specified maximum error, false otherwise. + + + + Compares two doubles and determines if they are equal + within the specified maximum error. + + The first value. + The second value. + The accuracy required for being almost equal. + True if both doubles are almost equal up to the specified maximum error, false otherwise. + + + + Compares two doubles and determines if they are equal within + the specified maximum error. + + The first value. + The second value. + The accuracy required for being almost equal. + + + + Compares two complex and determines if they are equal within + the specified maximum error. + + The first value. + The second value. + The accuracy required for being almost equal. + + + + Compares two complex and determines if they are equal within + the specified maximum error. + + The first value. + The second value. + The accuracy required for being almost equal. + + + + Compares two complex and determines if they are equal within + the specified maximum error. + + The first value. + The second value. + The accuracy required for being almost equal. + + + + Compares two doubles and determines if they are equal within + the specified maximum error. + + The first value. + The second value. + The accuracy required for being almost equal. + + + + Compares two complex and determines if they are equal within + the specified maximum error. + + The first value. + The second value. + The accuracy required for being almost equal. + + + + Compares two complex and determines if they are equal within + the specified maximum error. + + The first value. + The second value. + The accuracy required for being almost equal. + + + + Compares two complex and determines if they are equal within + the specified maximum error. + + The first value. + The second value. + The accuracy required for being almost equal. + + + + Checks whether two real numbers are almost equal. + + The first number + The second number + true if the two values differ by no more than 10 * 2^(-52); false otherwise. + + + + Checks whether two real numbers are almost equal. + + The first number + The second number + true if the two values differ by no more than 10 * 2^(-52); false otherwise. + + + + Checks whether two Complex numbers are almost equal. + + The first number + The second number + true if the two values differ by no more than 10 * 2^(-52); false otherwise. + + + + Checks whether two Complex numbers are almost equal. + + The first number + The second number + true if the two values differ by no more than 10 * 2^(-52); false otherwise. + + + + Checks whether two real numbers are almost equal. + + The first number + The second number + true if the two values differ by no more than 10 * 2^(-52); false otherwise. + + + + Checks whether two real numbers are almost equal. + + The first number + The second number + true if the two values differ by no more than 10 * 2^(-52); false otherwise. + + + + Checks whether two Complex numbers are almost equal. + + The first number + The second number + true if the two values differ by no more than 10 * 2^(-52); false otherwise. + + + + Checks whether two Complex numbers are almost equal. + + The first number + The second number + true if the two values differ by no more than 10 * 2^(-52); false otherwise. + + + + Compares two doubles and determines if they are equal to within the specified number of decimal places or not, using the + number of decimal places as an absolute measure. + + + + The values are equal if the difference between the two numbers is smaller than 0.5e-decimalPlaces. We divide by + two so that we have half the range on each side of the numbers, e.g. if == 2, then 0.01 will equal between + 0.005 and 0.015, but not 0.02 and not 0.00 + + + The norm of the first value (can be negative). + The norm of the second value (can be negative). + The norm of the difference of the two values (can be negative). + The number of decimal places. + + + + Compares two doubles and determines if they are equal to within the specified number of decimal places or not, using the + number of decimal places as an absolute measure. + + + + The values are equal if the difference between the two numbers is smaller than 0.5e-decimalPlaces. We divide by + two so that we have half the range on each side of the numbers, e.g. if == 2, then 0.01 will equal between + 0.005 and 0.015, but not 0.02 and not 0.00 + + + The first value. + The second value. + The number of decimal places. + + + + Compares two doubles and determines if they are equal to within the specified number of decimal places or not. If the numbers + are very close to zero an absolute difference is compared, otherwise the relative difference is compared. + + + + The values are equal if the difference between the two numbers is smaller than 10^(-numberOfDecimalPlaces). We divide by + two so that we have half the range on each side of the numbers, e.g. if == 2, then 0.01 will equal between + 0.005 and 0.015, but not 0.02 and not 0.00 + + + The norm of the first value (can be negative). + The norm of the second value (can be negative). + The norm of the difference of the two values (can be negative). + The number of decimal places. + Thrown if is smaller than zero. + + + + Compares two doubles and determines if they are equal to within the specified number of decimal places or not. If the numbers + are very close to zero an absolute difference is compared, otherwise the relative difference is compared. + + + + The values are equal if the difference between the two numbers is smaller than 10^(-numberOfDecimalPlaces). We divide by + two so that we have half the range on each side of the numbers, e.g. if == 2, then 0.01 will equal between + 0.005 and 0.015, but not 0.02 and not 0.00 + + + The first value. + The second value. + The number of decimal places. + + + + Compares two doubles and determines if they are equal to within the specified number of decimal places or not, using the + number of decimal places as an absolute measure. + + The first value. + The second value. + The number of decimal places. + + + + Compares two doubles and determines if they are equal to within the specified number of decimal places or not, using the + number of decimal places as an absolute measure. + + The first value. + The second value. + The number of decimal places. + + + + Compares two doubles and determines if they are equal to within the specified number of decimal places or not, using the + number of decimal places as an absolute measure. + + The first value. + The second value. + The number of decimal places. + + + + Compares two doubles and determines if they are equal to within the specified number of decimal places or not, using the + number of decimal places as an absolute measure. + + The first value. + The second value. + The number of decimal places. + + + + Compares two doubles and determines if they are equal to within the specified number of decimal places or not. If the numbers + are very close to zero an absolute difference is compared, otherwise the relative difference is compared. + + The first value. + The second value. + The number of decimal places. + + + + Compares two doubles and determines if they are equal to within the specified number of decimal places or not. If the numbers + are very close to zero an absolute difference is compared, otherwise the relative difference is compared. + + The first value. + The second value. + The number of decimal places. + + + + Compares two doubles and determines if they are equal to within the specified number of decimal places or not. If the numbers + are very close to zero an absolute difference is compared, otherwise the relative difference is compared. + + The first value. + The second value. + The number of decimal places. + + + + Compares two doubles and determines if they are equal to within the specified number of decimal places or not. If the numbers + are very close to zero an absolute difference is compared, otherwise the relative difference is compared. + + The first value. + The second value. + The number of decimal places. + + + + Compares two doubles and determines if they are equal to within the tolerance or not. Equality comparison is based on the binary representation. + + + + Determines the 'number' of floating point numbers between two values (i.e. the number of discrete steps + between the two numbers) and then checks if that is within the specified tolerance. So if a tolerance + of 1 is passed then the result will be true only if the two numbers have the same binary representation + OR if they are two adjacent numbers that only differ by one step. + + + The comparison method used is explained in http://www.cygnus-software.com/papers/comparingfloats/comparingfloats.htm . The article + at http://www.extremeoptimization.com/resources/Articles/FPDotNetConceptsAndFormats.aspx explains how to transform the C code to + .NET enabled code without using pointers and unsafe code. + + + The first value. + The second value. + The maximum number of floating point values between the two values. Must be 1 or larger. + Thrown if is smaller than one. + + + + Compares two floats and determines if they are equal to within the tolerance or not. Equality comparison is based on the binary representation. + + The first value. + The second value. + The maximum number of floating point values between the two values. Must be 1 or larger. + Thrown if is smaller than one. + + + + Compares two lists of doubles and determines if they are equal within the + specified maximum error. + + The first value list. + The second value list. + The accuracy required for being almost equal. + + + + Compares two lists of doubles and determines if they are equal within the + specified maximum error. + + The first value list. + The second value list. + The accuracy required for being almost equal. + + + + Compares two lists of doubles and determines if they are equal within the + specified maximum error. + + The first value list. + The second value list. + The accuracy required for being almost equal. + + + + Compares two lists of doubles and determines if they are equal within the + specified maximum error. + + The first value list. + The second value list. + The accuracy required for being almost equal. + + + + Compares two lists of doubles and determines if they are equal within the + specified maximum error. + + The first value list. + The second value list. + The accuracy required for being almost equal. + + + + Compares two lists of doubles and determines if they are equal within the + specified maximum error. + + The first value list. + The second value list. + The accuracy required for being almost equal. + + + + Compares two lists of doubles and determines if they are equal within the + specified maximum error. + + The first value list. + The second value list. + The accuracy required for being almost equal. + + + + Compares two lists of doubles and determines if they are equal within the + specified maximum error. + + The first value list. + The second value list. + The accuracy required for being almost equal. + + + + Compares two lists of doubles and determines if they are equal within the + specified maximum error. + + The first value list. + The second value list. + The number of decimal places. + + + + Compares two lists of doubles and determines if they are equal within the + specified maximum error. + + The first value list. + The second value list. + The number of decimal places. + + + + Compares two lists of doubles and determines if they are equal within the + specified maximum error. + + The first value list. + The second value list. + The number of decimal places. + + + + Compares two lists of doubles and determines if they are equal within the + specified maximum error. + + The first value list. + The second value list. + The number of decimal places. + + + + Compares two lists of doubles and determines if they are equal within the + specified maximum error. + + The first value list. + The second value list. + The number of decimal places. + + + + Compares two lists of doubles and determines if they are equal within the + specified maximum error. + + The first value list. + The second value list. + The number of decimal places. + + + + Compares two lists of doubles and determines if they are equal within the + specified maximum error. + + The first value list. + The second value list. + The number of decimal places. + + + + Compares two lists of doubles and determines if they are equal within the + specified maximum error. + + The first value list. + The second value list. + The number of decimal places. + + + + Compares two lists of doubles and determines if they are equal within the + specified maximum error. + + The first value list. + The second value list. + The accuracy required for being almost equal. + + + + Compares two lists of doubles and determines if they are equal within the + specified maximum error. + + The first value list. + The second value list. + The accuracy required for being almost equal. + + + + Compares two vectors and determines if they are equal within the specified maximum error. + + The first value. + The second value. + The accuracy required for being almost equal. + + + + Compares two vectors and determines if they are equal within the specified maximum error. + + The first value. + The second value. + The accuracy required for being almost equal. + + + + Compares two vectors and determines if they are equal to within the specified number + of decimal places or not, using the number of decimal places as an absolute measure. + + The first value. + The second value. + The number of decimal places. + + + + Compares two vectors and determines if they are equal to within the specified number of decimal places or not. + If the numbers are very close to zero an absolute difference is compared, otherwise the relative difference is compared. + + The first value. + The second value. + The number of decimal places. + + + + Compares two matrices and determines if they are equal within the specified maximum error. + + The first value. + The second value. + The accuracy required for being almost equal. + + + + Compares two matrices and determines if they are equal within the specified maximum error. + + The first value. + The second value. + The accuracy required for being almost equal. + + + + Compares two matrices and determines if they are equal to within the specified number + of decimal places or not, using the number of decimal places as an absolute measure. + + The first value. + The second value. + The number of decimal places. + + + + Compares two matrices and determines if they are equal to within the specified number of decimal places or not. + If the numbers are very close to zero an absolute difference is compared, otherwise the relative difference is compared. + + The first value. + The second value. + The number of decimal places. + + + + Support Interface for Precision Operations (like AlmostEquals). + + Type of the implementing class. + + + + Returns a Norm of a value of this type, which is appropriate for measuring how + close this value is to zero. + + A norm of this value. + + + + Returns a Norm of the difference of two values of this type, which is + appropriate for measuring how close together these two values are. + + The value to compare with. + A norm of the difference between this and the other value. + + + + Optional path to try to load native provider binaries from, + if the provider specific hint path is not set. + If neither is set, Numerics falls back to the provider specific + environment variables, or the default probing paths. + + + + + Gets or sets the Fourier transform provider. Consider to use UseNativeMKL or UseManaged instead. + + The linear algebra provider. + + + + Try to use a native provider, if available. + + + + + Use the best provider available. + + + + + Use a specific provider if configured, e.g. using the + "MathNetNumericsFFTProvider" environment variable, + or fall back to the best provider. + + + + + Try to find out whether the provider is available, at least in principle. + Verification may still fail if available, but it will certainly fail if unavailable. + + + + + Initialize and verify that the provided is indeed available. If not, fall back to alternatives like the managed provider + + + + + Frees memory buffers, caches and handles allocated in or to the provider. + Does not unload the provider itself, it is still usable afterwards. + + + + + Sequences with length greater than Math.Sqrt(Int32.MaxValue) + 1 + will cause k*k in the Bluestein sequence to overflow (GH-286). + + + + + Generate the bluestein sequence for the provided problem size. + + Number of samples. + Bluestein sequence exp(I*Pi*k^2/N) + + + + Generate the bluestein sequence for the provided problem size. + + Number of samples. + Bluestein sequence exp(I*Pi*k^2/N) + + + + Convolution with the bluestein sequence (Parallel Version). + + Sample Vector. + + + + Convolution with the bluestein sequence (Parallel Version). + + Sample Vector. + + + + Swap the real and imaginary parts of each sample. + + Sample Vector. + + + + Swap the real and imaginary parts of each sample. + + Sample Vector. + + + + Bluestein generic FFT for arbitrary sized sample vectors. + + + + + Bluestein generic FFT for arbitrary sized sample vectors. + + + + + Bluestein generic FFT for arbitrary sized sample vectors. + + + + + Bluestein generic FFT for arbitrary sized sample vectors. + + + + + Try to find out whether the provider is available, at least in principle. + Verification may still fail if available, but it will certainly fail if unavailable. + + + + + Initialize and verify that the provided is indeed available. If not, fall back to alternatives like the managed provider + + + + + Frees memory buffers, caches and handles allocated in or to the provider. + Does not unload the provider itself, it is still usable afterwards. + + + + + Radix-2 Reorder Helper Method + + Sample type + Sample vector + + + + Radix-2 Step Helper Method + + Sample vector. + Fourier series exponent sign. + Level Group Size. + Index inside of the level. + + + + Radix-2 Step Helper Method + + Sample vector. + Fourier series exponent sign. + Level Group Size. + Index inside of the level. + + + + Radix-2 generic FFT for power-of-two sized sample vectors. + + + + + Radix-2 generic FFT for power-of-two sized sample vectors. + + + + + Radix-2 generic FFT for power-of-two sized sample vectors. + + + + + Radix-2 generic FFT for power-of-two sized sample vectors. + + + + + Radix-2 generic FFT for power-of-two sample vectors (Parallel Version). + + + + + Radix-2 generic FFT for power-of-two sample vectors (Parallel Version). + + + + + Radix-2 generic FFT for power-of-two sample vectors (Parallel Version). + + + + + Radix-2 generic FFT for power-of-two sample vectors (Parallel Version). + + + + + Fully rescale the FFT result. + + Sample Vector. + + + + Fully rescale the FFT result. + + Sample Vector. + + + + Half rescale the FFT result (e.g. for symmetric transforms). + + Sample Vector. + + + + Fully rescale the FFT result (e.g. for symmetric transforms). + + Sample Vector. + + + + How to transpose a matrix. + + + + + Don't transpose a matrix. + + + + + Transpose a matrix. + + + + + Conjugate transpose a complex matrix. + + If a conjugate transpose is used with a real matrix, then the matrix is just transposed. + + + + Types of matrix norms. + + + + + The 1-norm. + + + + + The Frobenius norm. + + + + + The infinity norm. + + + + + The largest absolute value norm. + + + + + Interface to linear algebra algorithms that work off 1-D arrays. + + + + + Try to find out whether the provider is available, at least in principle. + Verification may still fail if available, but it will certainly fail if unavailable. + + + + + Initialize and verify that the provided is indeed available. If not, fall back to alternatives like the managed provider + + + + + Frees memory buffers, caches and handles allocated in or to the provider. + Does not unload the provider itself, it is still usable afterwards. + + + + + Interface to linear algebra algorithms that work off 1-D arrays. + + Supported data types are Double, Single, Complex, and Complex32. + + + + Adds a scaled vector to another: result = y + alpha*x. + + The vector to update. + The value to scale by. + The vector to add to . + The result of the addition. + This is similar to the AXPY BLAS routine. + + + + Scales an array. Can be used to scale a vector and a matrix. + + The scalar. + The values to scale. + This result of the scaling. + This is similar to the SCAL BLAS routine. + + + + Conjugates an array. Can be used to conjugate a vector and a matrix. + + The values to conjugate. + This result of the conjugation. + + + + Computes the dot product of x and y. + + The vector x. + The vector y. + The dot product of x and y. + This is equivalent to the DOT BLAS routine. + + + + Does a point wise add of two arrays z = x + y. This can be used + to add vectors or matrices. + + The array x. + The array y. + The result of the addition. + There is no equivalent BLAS routine, but many libraries + provide optimized (parallel and/or vectorized) versions of this + routine. + + + + Does a point wise subtraction of two arrays z = x - y. This can be used + to subtract vectors or matrices. + + The array x. + The array y. + The result of the subtraction. + There is no equivalent BLAS routine, but many libraries + provide optimized (parallel and/or vectorized) versions of this + routine. + + + + Does a point wise multiplication of two arrays z = x * y. This can be used + to multiply elements of vectors or matrices. + + The array x. + The array y. + The result of the point wise multiplication. + There is no equivalent BLAS routine, but many libraries + provide optimized (parallel and/or vectorized) versions of this + routine. + + + + Does a point wise division of two arrays z = x / y. This can be used + to divide elements of vectors or matrices. + + The array x. + The array y. + The result of the point wise division. + There is no equivalent BLAS routine, but many libraries + provide optimized (parallel and/or vectorized) versions of this + routine. + + + + Does a point wise power of two arrays z = x ^ y. This can be used + to raise elements of vectors or matrices to the powers of another vector or matrix. + + The array x. + The array y. + The result of the point wise power. + There is no equivalent BLAS routine, but many libraries + provide optimized (parallel and/or vectorized) versions of this + routine. + + + + Computes the requested of the matrix. + + The type of norm to compute. + The number of rows. + The number of columns. + The matrix to compute the norm from. + + The requested of the matrix. + + + + + Multiples two matrices. result = x * y + + The x matrix. + The number of rows in the x matrix. + The number of columns in the x matrix. + The y matrix. + The number of rows in the y matrix. + The number of columns in the y matrix. + Where to store the result of the multiplication. + This is a simplified version of the BLAS GEMM routine with alpha + set to 1.0 and beta set to 0.0, and x and y are not transposed. + + + + Multiplies two matrices and updates another with the result. c = alpha*op(a)*op(b) + beta*c + + How to transpose the matrix. + How to transpose the matrix. + The value to scale matrix. + The a matrix. + The number of rows in the matrix. + The number of columns in the matrix. + The b matrix + The number of rows in the matrix. + The number of columns in the matrix. + The value to scale the matrix. + The c matrix. + + + + Computes the LUP factorization of A. P*A = L*U. + + An by matrix. The matrix is overwritten with the + the LU factorization on exit. The lower triangular factor L is stored in under the diagonal of (the diagonal is always 1.0 + for the L factor). The upper triangular factor U is stored on and above the diagonal of . + The order of the square matrix . + On exit, it contains the pivot indices. The size of the array must be . + This is equivalent to the GETRF LAPACK routine. + + + + Computes the inverse of matrix using LU factorization. + + The N by N matrix to invert. Contains the inverse On exit. + The order of the square matrix . + This is equivalent to the GETRF and GETRI LAPACK routines. + + + + Computes the inverse of a previously factored matrix. + + The LU factored N by N matrix. Contains the inverse On exit. + The order of the square matrix . + The pivot indices of . + This is equivalent to the GETRI LAPACK routine. + + + + Solves A*X=B for X using LU factorization. + + The number of columns of B. + The square matrix A. + The order of the square matrix . + On entry the B matrix; on exit the X matrix. + This is equivalent to the GETRF and GETRS LAPACK routines. + + + + Solves A*X=B for X using a previously factored A matrix. + + The number of columns of B. + The factored A matrix. + The order of the square matrix . + The pivot indices of . + On entry the B matrix; on exit the X matrix. + This is equivalent to the GETRS LAPACK routine. + + + + Computes the Cholesky factorization of A. + + On entry, a square, positive definite matrix. On exit, the matrix is overwritten with the + the Cholesky factorization. + The number of rows or columns in the matrix. + This is equivalent to the POTRF LAPACK routine. + + + + Solves A*X=B for X using Cholesky factorization. + + The square, positive definite matrix A. + The number of rows and columns in A. + On entry the B matrix; on exit the X matrix. + The number of columns in the B matrix. + This is equivalent to the POTRF add POTRS LAPACK routines. + + + + Solves A*X=B for X using a previously factored A matrix. + + The square, positive definite matrix A. + The number of rows and columns in A. + On entry the B matrix; on exit the X matrix. + The number of columns in the B matrix. + This is equivalent to the POTRS LAPACK routine. + + + + Computes the full QR factorization of A. + + On entry, it is the M by N A matrix to factor. On exit, + it is overwritten with the R matrix of the QR factorization. + The number of rows in the A matrix. + The number of columns in the A matrix. + On exit, A M by M matrix that holds the Q matrix of the + QR factorization. + A min(m,n) vector. On exit, contains additional information + to be used by the QR solve routine. + This is similar to the GEQRF and ORGQR LAPACK routines. + + + + Computes the thin QR factorization of A where M > N. + + On entry, it is the M by N A matrix to factor. On exit, + it is overwritten with the Q matrix of the QR factorization. + The number of rows in the A matrix. + The number of columns in the A matrix. + On exit, A N by N matrix that holds the R matrix of the + QR factorization. + A min(m,n) vector. On exit, contains additional information + to be used by the QR solve routine. + This is similar to the GEQRF and ORGQR LAPACK routines. + + + + Solves A*X=B for X using QR factorization of A. + + The A matrix. + The number of rows in the A matrix. + The number of columns in the A matrix. + The B matrix. + The number of columns of B. + On exit, the solution matrix. + The type of QR factorization to perform. + Rows must be greater or equal to columns. + + + + Solves A*X=B for X using a previously QR factored matrix. + + The Q matrix obtained by QR factor. This is only used for the managed provider and can be + null for the native provider. The native provider uses the Q portion stored in the R matrix. + The R matrix obtained by calling . + The number of rows in the A matrix. + The number of columns in the A matrix. + Contains additional information on Q. Only used for the native solver + and can be null for the managed provider. + On entry the B matrix; on exit the X matrix. + The number of columns of B. + On exit, the solution matrix. + Rows must be greater or equal to columns. + The type of QR factorization to perform. + + + + Computes the singular value decomposition of A. + + Compute the singular U and VT vectors or not. + On entry, the M by N matrix to decompose. On exit, A may be overwritten. + The number of rows in the A matrix. + The number of columns in the A matrix. + The singular values of A in ascending value. + If is true, on exit U contains the left + singular vectors. + If is true, on exit VT contains the transposed + right singular vectors. + This is equivalent to the GESVD LAPACK routine. + + + + Solves A*X=B for X using the singular value decomposition of A. + + On entry, the M by N matrix to decompose. + The number of rows in the A matrix. + The number of columns in the A matrix. + The B matrix. + The number of columns of B. + On exit, the solution matrix. + + + + Solves A*X=B for X using a previously SVD decomposed matrix. + + The number of rows in the A matrix. + The number of columns in the A matrix. + The s values returned by . + The left singular vectors returned by . + The right singular vectors returned by . + The B matrix + The number of columns of B. + On exit, the solution matrix. + + + + Computes the eigenvalues and eigenvectors of a matrix. + + Whether the matrix is symmetric or not. + The order of the matrix. + The matrix to decompose. The length of the array must be order * order. + On output, the matrix contains the eigen vectors. The length of the array must be order * order. + On output, the eigen values (λ) of matrix in ascending value. The length of the array must . + On output, the block diagonal eigenvalue matrix. The length of the array must be order * order. + + + + Optional path to try to load native provider binaries from, + if the provider specific hint path is not set. + If neither is set, Numerics falls back to the provider specific + environment variables, or the default probing paths. + + + + + Gets or sets the linear algebra provider. + Consider to use UseNativeMKL or UseManaged instead. + + The linear algebra provider. + + + + Try to use a native provider, if available. + + + + + Use the best provider available. + + + + + Use a specific provider if configured, e.g. using the + "MathNetNumericsLAProvider" environment variable, + or fall back to the best provider. + + + + + The managed linear algebra provider. + + + The managed linear algebra provider. + + + The managed linear algebra provider. + + + The managed linear algebra provider. + + + The managed linear algebra provider. + + + + + Adds a scaled vector to another: result = y + alpha*x. + + The vector to update. + The value to scale by. + The vector to add to . + The result of the addition. + This is similar to the AXPY BLAS routine. + + + + Scales an array. Can be used to scale a vector and a matrix. + + The scalar. + The values to scale. + This result of the scaling. + This is similar to the SCAL BLAS routine. + + + + Conjugates an array. Can be used to conjugate a vector and a matrix. + + The values to conjugate. + This result of the conjugation. + + + + Computes the dot product of x and y. + + The vector x. + The vector y. + The dot product of x and y. + This is equivalent to the DOT BLAS routine. + + + + Does a point wise add of two arrays z = x + y. This can be used + to add vectors or matrices. + + The array x. + The array y. + The result of the addition. + There is no equivalent BLAS routine, but many libraries + provide optimized (parallel and/or vectorized) versions of this + routine. + + + + Does a point wise subtraction of two arrays z = x - y. This can be used + to subtract vectors or matrices. + + The array x. + The array y. + The result of the subtraction. + There is no equivalent BLAS routine, but many libraries + provide optimized (parallel and/or vectorized) versions of this + routine. + + + + Does a point wise multiplication of two arrays z = x * y. This can be used + to multiple elements of vectors or matrices. + + The array x. + The array y. + The result of the point wise multiplication. + There is no equivalent BLAS routine, but many libraries + provide optimized (parallel and/or vectorized) versions of this + routine. + + + + Does a point wise division of two arrays z = x / y. This can be used + to divide elements of vectors or matrices. + + The array x. + The array y. + The result of the point wise division. + There is no equivalent BLAS routine, but many libraries + provide optimized (parallel and/or vectorized) versions of this + routine. + + + + Does a point wise power of two arrays z = x ^ y. This can be used + to raise elements of vectors or matrices to the powers of another vector or matrix. + + The array x. + The array y. + The result of the point wise power. + There is no equivalent BLAS routine, but many libraries + provide optimized (parallel and/or vectorized) versions of this + routine. + + + + Computes the requested of the matrix. + + The type of norm to compute. + The number of rows. + The number of columns. + The matrix to compute the norm from. + + The requested of the matrix. + + + + + Multiples two matrices. result = x * y + + The x matrix. + The number of rows in the x matrix. + The number of columns in the x matrix. + The y matrix. + The number of rows in the y matrix. + The number of columns in the y matrix. + Where to store the result of the multiplication. + This is a simplified version of the BLAS GEMM routine with alpha + set to 1.0 and beta set to 0.0, and x and y are not transposed. + + + + Multiplies two matrices and updates another with the result. c = alpha*op(a)*op(b) + beta*c + + How to transpose the matrix. + How to transpose the matrix. + The value to scale matrix. + The a matrix. + The number of rows in the matrix. + The number of columns in the matrix. + The b matrix + The number of rows in the matrix. + The number of columns in the matrix. + The value to scale the matrix. + The c matrix. + + + + Computes the LUP factorization of A. P*A = L*U. + + An by matrix. The matrix is overwritten with the + the LU factorization on exit. The lower triangular factor L is stored in under the diagonal of (the diagonal is always 1.0 + for the L factor). The upper triangular factor U is stored on and above the diagonal of . + The order of the square matrix . + On exit, it contains the pivot indices. The size of the array must be . + This is equivalent to the GETRF LAPACK routine. + + + + Computes the inverse of matrix using LU factorization. + + The N by N matrix to invert. Contains the inverse On exit. + The order of the square matrix . + This is equivalent to the GETRF and GETRI LAPACK routines. + + + + Computes the inverse of a previously factored matrix. + + The LU factored N by N matrix. Contains the inverse On exit. + The order of the square matrix . + The pivot indices of . + This is equivalent to the GETRI LAPACK routine. + + + + Solves A*X=B for X using LU factorization. + + The number of columns of B. + The square matrix A. + The order of the square matrix . + On entry the B matrix; on exit the X matrix. + This is equivalent to the GETRF and GETRS LAPACK routines. + + + + Solves A*X=B for X using a previously factored A matrix. + + The number of columns of B. + The factored A matrix. + The order of the square matrix . + The pivot indices of . + On entry the B matrix; on exit the X matrix. + This is equivalent to the GETRS LAPACK routine. + + + + Computes the Cholesky factorization of A. + + On entry, a square, positive definite matrix. On exit, the matrix is overwritten with the + the Cholesky factorization. + The number of rows or columns in the matrix. + This is equivalent to the POTRF LAPACK routine. + + + + Calculate Cholesky step + + Factor matrix + Number of rows + Column start + Total columns + Multipliers calculated previously + Number of available processors + + + + Solves A*X=B for X using Cholesky factorization. + + The square, positive definite matrix A. + The number of rows and columns in A. + On entry the B matrix; on exit the X matrix. + The number of columns in the B matrix. + This is equivalent to the POTRF add POTRS LAPACK routines. + + + + Solves A*X=B for X using a previously factored A matrix. + + The square, positive definite matrix A. + The number of rows and columns in A. + The B matrix. + The number of columns in the B matrix. + This is equivalent to the POTRS LAPACK routine. + + + + Solves A*X=B for X using a previously factored A matrix. + + The square, positive definite matrix A. Has to be different than . + The number of rows and columns in A. + On entry the B matrix; on exit the X matrix. + The column to solve for. + + + + Computes the QR factorization of A. + + On entry, it is the M by N A matrix to factor. On exit, + it is overwritten with the R matrix of the QR factorization. + The number of rows in the A matrix. + The number of columns in the A matrix. + On exit, A M by M matrix that holds the Q matrix of the + QR factorization. + A min(m,n) vector. On exit, contains additional information + to be used by the QR solve routine. + This is similar to the GEQRF and ORGQR LAPACK routines. + + + + Computes the QR factorization of A. + + On entry, it is the M by N A matrix to factor. On exit, + it is overwritten with the Q matrix of the QR factorization. + The number of rows in the A matrix. + The number of columns in the A matrix. + On exit, A N by N matrix that holds the R matrix of the + QR factorization. + A min(m,n) vector. On exit, contains additional information + to be used by the QR solve routine. + This is similar to the GEQRF and ORGQR LAPACK routines. + + + + Perform calculation of Q or R + + Work array + Index of column in work array + Q or R matrices + The first row in + The last row + The first column + The last column + Number of available CPUs + + + + Generate column from initial matrix to work array + + Work array + Initial matrix + The number of rows in matrix + The first row + Column index + + + + Solves A*X=B for X using QR factorization of A. + + The A matrix. + The number of rows in the A matrix. + The number of columns in the A matrix. + The B matrix. + The number of columns of B. + On exit, the solution matrix. + The type of QR factorization to perform. + Rows must be greater or equal to columns. + + + + Solves A*X=B for X using a previously QR factored matrix. + + The Q matrix obtained by calling . + The R matrix obtained by calling . + The number of rows in the A matrix. + The number of columns in the A matrix. + Contains additional information on Q. Only used for the native solver + and can be null for the managed provider. + The B matrix. + The number of columns of B. + On exit, the solution matrix. + The type of QR factorization to perform. + Rows must be greater or equal to columns. + + + + Computes the singular value decomposition of A. + + Compute the singular U and VT vectors or not. + On entry, the M by N matrix to decompose. On exit, A may be overwritten. + The number of rows in the A matrix. + The number of columns in the A matrix. + The singular values of A in ascending value. + If is true, on exit U contains the left + singular vectors. + If is true, on exit VT contains the transposed + right singular vectors. + This is equivalent to the GESVD LAPACK routine. + + + + Solves A*X=B for X using the singular value decomposition of A. + + On entry, the M by N matrix to decompose. + The number of rows in the A matrix. + The number of columns in the A matrix. + The B matrix. + The number of columns of B. + On exit, the solution matrix. + + + + Solves A*X=B for X using a previously SVD decomposed matrix. + + The number of rows in the A matrix. + The number of columns in the A matrix. + The s values returned by . + The left singular vectors returned by . + The right singular vectors returned by . + The B matrix. + The number of columns of B. + On exit, the solution matrix. + + + + Computes the eigenvalues and eigenvectors of a matrix. + + Whether the matrix is symmetric or not. + The order of the matrix. + The matrix to decompose. The length of the array must be order * order. + On output, the matrix contains the eigen vectors. The length of the array must be order * order. + On output, the eigen values (λ) of matrix in ascending value. The length of the array must . + On output, the block diagonal eigenvalue matrix. The length of the array must be order * order. + + + + Reduces a complex Hermitian matrix to a real symmetric tridiagonal matrix using unitary similarity transformations. + + Source matrix to reduce + Output: Arrays for internal storage of real parts of eigenvalues + Output: Arrays for internal storage of imaginary parts of eigenvalues + Output: Arrays that contains further information about the transformations. + Order of initial matrix + This is derived from the Algol procedures HTRIDI by + Smith, Boyle, Dongarra, Garbow, Ikebe, Klema, Moler, and Wilkinson, Handbook for + Auto. Comp., Vol.ii-Linear Algebra, and the corresponding + Fortran subroutine in EISPACK. + + + + Symmetric tridiagonal QL algorithm. + + Data array of matrix V (eigenvectors) + Arrays for internal storage of real parts of eigenvalues + Arrays for internal storage of imaginary parts of eigenvalues + Order of initial matrix + This is derived from the Algol procedures tql2, by + Bowdler, Martin, Reinsch, and Wilkinson, Handbook for + Auto. Comp., Vol.ii-Linear Algebra, and the corresponding + Fortran subroutine in EISPACK. + + + + + Determines eigenvectors by undoing the symmetric tridiagonalize transformation + + Data array of matrix V (eigenvectors) + Previously tridiagonalized matrix by SymmetricTridiagonalize. + Contains further information about the transformations + Input matrix order + This is derived from the Algol procedures HTRIBK, by + by Smith, Boyle, Dongarra, Garbow, Ikebe, Klema, Moler, and Wilkinson, Handbook for + Auto. Comp., Vol.ii-Linear Algebra, and the corresponding + Fortran subroutine in EISPACK. + + + + Nonsymmetric reduction to Hessenberg form. + + Data array of matrix V (eigenvectors) + Array for internal storage of nonsymmetric Hessenberg form. + Order of initial matrix + This is derived from the Algol procedures orthes and ortran, + by Martin and Wilkinson, Handbook for Auto. Comp., + Vol.ii-Linear Algebra, and the corresponding + Fortran subroutines in EISPACK. + + + + Nonsymmetric reduction from Hessenberg to real Schur form. + + Data array of the eigenvectors + Data array of matrix V (eigenvectors) + Array for internal storage of nonsymmetric Hessenberg form. + Order of initial matrix + This is derived from the Algol procedure hqr2, + by Martin and Wilkinson, Handbook for Auto. Comp., + Vol.ii-Linear Algebra, and the corresponding + Fortran subroutine in EISPACK. + + + + Assumes that and have already been transposed. + + + + + Assumes that and have already been transposed. + + + + + Adds a scaled vector to another: result = y + alpha*x. + + The vector to update. + The value to scale by. + The vector to add to . + The result of the addition. + This is similar to the AXPY BLAS routine. + + + + Scales an array. Can be used to scale a vector and a matrix. + + The scalar. + The values to scale. + This result of the scaling. + This is similar to the SCAL BLAS routine. + + + + Conjugates an array. Can be used to conjugate a vector and a matrix. + + The values to conjugate. + This result of the conjugation. + + + + Computes the dot product of x and y. + + The vector x. + The vector y. + The dot product of x and y. + This is equivalent to the DOT BLAS routine. + + + + Does a point wise add of two arrays z = x + y. This can be used + to add vectors or matrices. + + The array x. + The array y. + The result of the addition. + There is no equivalent BLAS routine, but many libraries + provide optimized (parallel and/or vectorized) versions of this + routine. + + + + Does a point wise subtraction of two arrays z = x - y. This can be used + to subtract vectors or matrices. + + The array x. + The array y. + The result of the subtraction. + There is no equivalent BLAS routine, but many libraries + provide optimized (parallel and/or vectorized) versions of this + routine. + + + + Does a point wise multiplication of two arrays z = x * y. This can be used + to multiple elements of vectors or matrices. + + The array x. + The array y. + The result of the point wise multiplication. + There is no equivalent BLAS routine, but many libraries + provide optimized (parallel and/or vectorized) versions of this + routine. + + + + Does a point wise division of two arrays z = x / y. This can be used + to divide elements of vectors or matrices. + + The array x. + The array y. + The result of the point wise division. + There is no equivalent BLAS routine, but many libraries + provide optimized (parallel and/or vectorized) versions of this + routine. + + + + Does a point wise power of two arrays z = x ^ y. This can be used + to raise elements of vectors or matrices to the powers of another vector or matrix. + + The array x. + The array y. + The result of the point wise power. + There is no equivalent BLAS routine, but many libraries + provide optimized (parallel and/or vectorized) versions of this + routine. + + + + Computes the requested of the matrix. + + The type of norm to compute. + The number of rows. + The number of columns. + The matrix to compute the norm from. + The requested of the matrix. + + + + Multiples two matrices. result = x * y + + The x matrix. + The number of rows in the x matrix. + The number of columns in the x matrix. + The y matrix. + The number of rows in the y matrix. + The number of columns in the y matrix. + Where to store the result of the multiplication. + This is a simplified version of the BLAS GEMM routine with alpha + set to 1.0 and beta set to 0.0, and x and y are not transposed. + + + + Multiplies two matrices and updates another with the result. c = alpha*op(a)*op(b) + beta*c + + How to transpose the matrix. + How to transpose the matrix. + The value to scale matrix. + The a matrix. + The number of rows in the matrix. + The number of columns in the matrix. + The b matrix + The number of rows in the matrix. + The number of columns in the matrix. + The value to scale the matrix. + The c matrix. + + + + Computes the LUP factorization of A. P*A = L*U. + + An by matrix. The matrix is overwritten with the + the LU factorization on exit. The lower triangular factor L is stored in under the diagonal of (the diagonal is always 1.0 + for the L factor). The upper triangular factor U is stored on and above the diagonal of . + The order of the square matrix . + On exit, it contains the pivot indices. The size of the array must be . + This is equivalent to the GETRF LAPACK routine. + + + + Computes the inverse of matrix using LU factorization. + + The N by N matrix to invert. Contains the inverse On exit. + The order of the square matrix . + This is equivalent to the GETRF and GETRI LAPACK routines. + + + + Computes the inverse of a previously factored matrix. + + The LU factored N by N matrix. Contains the inverse On exit. + The order of the square matrix . + The pivot indices of . + This is equivalent to the GETRI LAPACK routine. + + + + Solves A*X=B for X using LU factorization. + + The number of columns of B. + The square matrix A. + The order of the square matrix . + On entry the B matrix; on exit the X matrix. + This is equivalent to the GETRF and GETRS LAPACK routines. + + + + Solves A*X=B for X using a previously factored A matrix. + + The number of columns of B. + The factored A matrix. + The order of the square matrix . + The pivot indices of . + On entry the B matrix; on exit the X matrix. + This is equivalent to the GETRS LAPACK routine. + + + + Computes the Cholesky factorization of A. + + On entry, a square, positive definite matrix. On exit, the matrix is overwritten with the + the Cholesky factorization. + The number of rows or columns in the matrix. + This is equivalent to the POTRF LAPACK routine. + + + + Calculate Cholesky step + + Factor matrix + Number of rows + Column start + Total columns + Multipliers calculated previously + Number of available processors + + + + Solves A*X=B for X using Cholesky factorization. + + The square, positive definite matrix A. + The number of rows and columns in A. + On entry the B matrix; on exit the X matrix. + The number of columns in the B matrix. + This is equivalent to the POTRF add POTRS LAPACK routines. + + + + Solves A*X=B for X using a previously factored A matrix. + + The square, positive definite matrix A. + The number of rows and columns in A. + On entry the B matrix; on exit the X matrix. + The number of columns in the B matrix. + This is equivalent to the POTRS LAPACK routine. + + + + Solves A*X=B for X using a previously factored A matrix. + + The square, positive definite matrix A. Has to be different than . + The number of rows and columns in A. + On entry the B matrix; on exit the X matrix. + The column to solve for. + + + + Computes the QR factorization of A. + + On entry, it is the M by N A matrix to factor. On exit, + it is overwritten with the R matrix of the QR factorization. + The number of rows in the A matrix. + The number of columns in the A matrix. + On exit, A M by M matrix that holds the Q matrix of the + QR factorization. + A min(m,n) vector. On exit, contains additional information + to be used by the QR solve routine. + This is similar to the GEQRF and ORGQR LAPACK routines. + + + + Computes the QR factorization of A. + + On entry, it is the M by N A matrix to factor. On exit, + it is overwritten with the Q matrix of the QR factorization. + The number of rows in the A matrix. + The number of columns in the A matrix. + On exit, A N by N matrix that holds the R matrix of the + QR factorization. + A min(m,n) vector. On exit, contains additional information + to be used by the QR solve routine. + This is similar to the GEQRF and ORGQR LAPACK routines. + + + + Perform calculation of Q or R + + Work array + Index of column in work array + Q or R matrices + The first row in + The last row + The first column + The last column + Number of available CPUs + + + + Generate column from initial matrix to work array + + Work array + Initial matrix + The number of rows in matrix + The first row + Column index + + + + Solves A*X=B for X using QR factorization of A. + + The A matrix. + The number of rows in the A matrix. + The number of columns in the A matrix. + The B matrix. + The number of columns of B. + On exit, the solution matrix. + The type of QR factorization to perform. + Rows must be greater or equal to columns. + + + + Solves A*X=B for X using a previously QR factored matrix. + + The Q matrix obtained by calling . + The R matrix obtained by calling . + The number of rows in the A matrix. + The number of columns in the A matrix. + Contains additional information on Q. Only used for the native solver + and can be null for the managed provider. + The B matrix. + The number of columns of B. + On exit, the solution matrix. + The type of QR factorization to perform. + Rows must be greater or equal to columns. + + + + Computes the singular value decomposition of A. + + Compute the singular U and VT vectors or not. + On entry, the M by N matrix to decompose. On exit, A may be overwritten. + The number of rows in the A matrix. + The number of columns in the A matrix. + The singular values of A in ascending value. + If is true, on exit U contains the left + singular vectors. + If is true, on exit VT contains the transposed + right singular vectors. + This is equivalent to the GESVD LAPACK routine. + + + + Solves A*X=B for X using the singular value decomposition of A. + + On entry, the M by N matrix to decompose. + The number of rows in the A matrix. + The number of columns in the A matrix. + The B matrix. + The number of columns of B. + On exit, the solution matrix. + + + + Solves A*X=B for X using a previously SVD decomposed matrix. + + The number of rows in the A matrix. + The number of columns in the A matrix. + The s values returned by . + The left singular vectors returned by . + The right singular vectors returned by . + The B matrix. + The number of columns of B. + On exit, the solution matrix. + + + + Computes the eigenvalues and eigenvectors of a matrix. + + Whether the matrix is symmetric or not. + The order of the matrix. + The matrix to decompose. The length of the array must be order * order. + On output, the matrix contains the eigen vectors. The length of the array must be order * order. + On output, the eigen values (λ) of matrix in ascending value. The length of the array must . + On output, the block diagonal eigenvalue matrix. The length of the array must be order * order. + + + + Reduces a complex Hermitian matrix to a real symmetric tridiagonal matrix using unitary similarity transformations. + + Source matrix to reduce + Output: Arrays for internal storage of real parts of eigenvalues + Output: Arrays for internal storage of imaginary parts of eigenvalues + Output: Arrays that contains further information about the transformations. + Order of initial matrix + This is derived from the Algol procedures HTRIDI by + Smith, Boyle, Dongarra, Garbow, Ikebe, Klema, Moler, and Wilkinson, Handbook for + Auto. Comp., Vol.ii-Linear Algebra, and the corresponding + Fortran subroutine in EISPACK. + + + + Symmetric tridiagonal QL algorithm. + + Data array of matrix V (eigenvectors) + Arrays for internal storage of real parts of eigenvalues + Arrays for internal storage of imaginary parts of eigenvalues + Order of initial matrix + This is derived from the Algol procedures tql2, by + Bowdler, Martin, Reinsch, and Wilkinson, Handbook for + Auto. Comp., Vol.ii-Linear Algebra, and the corresponding + Fortran subroutine in EISPACK. + + + + + Determines eigenvectors by undoing the symmetric tridiagonalize transformation + + Data array of matrix V (eigenvectors) + Previously tridiagonalized matrix by SymmetricTridiagonalize. + Contains further information about the transformations + Input matrix order + This is derived from the Algol procedures HTRIBK, by + by Smith, Boyle, Dongarra, Garbow, Ikebe, Klema, Moler, and Wilkinson, Handbook for + Auto. Comp., Vol.ii-Linear Algebra, and the corresponding + Fortran subroutine in EISPACK. + + + + Nonsymmetric reduction to Hessenberg form. + + Data array of matrix V (eigenvectors) + Array for internal storage of nonsymmetric Hessenberg form. + Order of initial matrix + This is derived from the Algol procedures orthes and ortran, + by Martin and Wilkinson, Handbook for Auto. Comp., + Vol.ii-Linear Algebra, and the corresponding + Fortran subroutines in EISPACK. + + + + Nonsymmetric reduction from Hessenberg to real Schur form. + + Data array of the eigenvectors + Data array of matrix V (eigenvectors) + Array for internal storage of nonsymmetric Hessenberg form. + Order of initial matrix + This is derived from the Algol procedure hqr2, + by Martin and Wilkinson, Handbook for Auto. Comp., + Vol.ii-Linear Algebra, and the corresponding + Fortran subroutine in EISPACK. + + + + Assumes that and have already been transposed. + + + + + Assumes that and have already been transposed. + + + + + Try to find out whether the provider is available, at least in principle. + Verification may still fail if available, but it will certainly fail if unavailable. + + + + + Initialize and verify that the provided is indeed available. If not, fall back to alternatives like the managed provider + + + + + Frees memory buffers, caches and handles allocated in or to the provider. + Does not unload the provider itself, it is still usable afterwards. + + + + + Assumes that and have already been transposed. + + + + + Assumes that and have already been transposed. + + + + + Adds a scaled vector to another: result = y + alpha*x. + + The vector to update. + The value to scale by. + The vector to add to . + The result of the addition. + This is similar to the AXPY BLAS routine. + + + + Scales an array. Can be used to scale a vector and a matrix. + + The scalar. + The values to scale. + This result of the scaling. + This is similar to the SCAL BLAS routine. + + + + Conjugates an array. Can be used to conjugate a vector and a matrix. + + The values to conjugate. + This result of the conjugation. + + + + Computes the dot product of x and y. + + The vector x. + The vector y. + The dot product of x and y. + This is equivalent to the DOT BLAS routine. + + + + Does a point wise add of two arrays z = x + y. This can be used + to add vectors or matrices. + + The array x. + The array y. + The result of the addition. + There is no equivalent BLAS routine, but many libraries + provide optimized (parallel and/or vectorized) versions of this + routine. + + + + Does a point wise subtraction of two arrays z = x - y. This can be used + to subtract vectors or matrices. + + The array x. + The array y. + The result of the subtraction. + There is no equivalent BLAS routine, but many libraries + provide optimized (parallel and/or vectorized) versions of this + routine. + + + + Does a point wise multiplication of two arrays z = x * y. This can be used + to multiple elements of vectors or matrices. + + The array x. + The array y. + The result of the point wise multiplication. + There is no equivalent BLAS routine, but many libraries + provide optimized (parallel and/or vectorized) versions of this + routine. + + + + Does a point wise division of two arrays z = x / y. This can be used + to divide elements of vectors or matrices. + + The array x. + The array y. + The result of the point wise division. + There is no equivalent BLAS routine, but many libraries + provide optimized (parallel and/or vectorized) versions of this + routine. + + + + Does a point wise power of two arrays z = x ^ y. This can be used + to raise elements of vectors or matrices to the powers of another vector or matrix. + + The array x. + The array y. + The result of the point wise power. + There is no equivalent BLAS routine, but many libraries + provide optimized (parallel and/or vectorized) versions of this + routine. + + + + Computes the requested of the matrix. + + The type of norm to compute. + The number of rows. + The number of columns. + The matrix to compute the norm from. + + The requested of the matrix. + + + + + Multiples two matrices. result = x * y + + The x matrix. + The number of rows in the x matrix. + The number of columns in the x matrix. + The y matrix. + The number of rows in the y matrix. + The number of columns in the y matrix. + Where to store the result of the multiplication. + This is a simplified version of the BLAS GEMM routine with alpha + set to 1.0 and beta set to 0.0, and x and y are not transposed. + + + + Multiplies two matrices and updates another with the result. c = alpha*op(a)*op(b) + beta*c + + How to transpose the matrix. + How to transpose the matrix. + The value to scale matrix. + The a matrix. + The number of rows in the matrix. + The number of columns in the matrix. + The b matrix + The number of rows in the matrix. + The number of columns in the matrix. + The value to scale the matrix. + The c matrix. + + + + Computes the LUP factorization of A. P*A = L*U. + + An by matrix. The matrix is overwritten with the + the LU factorization on exit. The lower triangular factor L is stored in under the diagonal of (the diagonal is always 1.0 + for the L factor). The upper triangular factor U is stored on and above the diagonal of . + The order of the square matrix . + On exit, it contains the pivot indices. The size of the array must be . + This is equivalent to the GETRF LAPACK routine. + + + + Computes the inverse of matrix using LU factorization. + + The N by N matrix to invert. Contains the inverse On exit. + The order of the square matrix . + This is equivalent to the GETRF and GETRI LAPACK routines. + + + + Computes the inverse of a previously factored matrix. + + The LU factored N by N matrix. Contains the inverse On exit. + The order of the square matrix . + The pivot indices of . + This is equivalent to the GETRI LAPACK routine. + + + + Solves A*X=B for X using LU factorization. + + The number of columns of B. + The square matrix A. + The order of the square matrix . + On entry the B matrix; on exit the X matrix. + This is equivalent to the GETRF and GETRS LAPACK routines. + + + + Solves A*X=B for X using a previously factored A matrix. + + The number of columns of B. + The factored A matrix. + The order of the square matrix . + The pivot indices of . + On entry the B matrix; on exit the X matrix. + This is equivalent to the GETRS LAPACK routine. + + + + Computes the Cholesky factorization of A. + + On entry, a square, positive definite matrix. On exit, the matrix is overwritten with the + the Cholesky factorization. + The number of rows or columns in the matrix. + This is equivalent to the POTRF LAPACK routine. + + + + Calculate Cholesky step + + Factor matrix + Number of rows + Column start + Total columns + Multipliers calculated previously + Number of available processors + + + + Solves A*X=B for X using Cholesky factorization. + + The square, positive definite matrix A. + The number of rows and columns in A. + On entry the B matrix; on exit the X matrix. + The number of columns in the B matrix. + This is equivalent to the POTRF add POTRS LAPACK routines. + + + + Solves A*X=B for X using a previously factored A matrix. + + The square, positive definite matrix A. Has to be different than . + The number of rows and columns in A. + On entry the B matrix; on exit the X matrix. + The number of columns in the B matrix. + This is equivalent to the POTRS LAPACK routine. + + + + Solves A*X=B for X using a previously factored A matrix. + + The square, positive definite matrix A. Has to be different than . + The number of rows and columns in A. + On entry the B matrix; on exit the X matrix. + The column to solve for. + + + + Computes the QR factorization of A. + + On entry, it is the M by N A matrix to factor. On exit, + it is overwritten with the R matrix of the QR factorization. + The number of rows in the A matrix. + The number of columns in the A matrix. + On exit, A M by M matrix that holds the Q matrix of the + QR factorization. + A min(m,n) vector. On exit, contains additional information + to be used by the QR solve routine. + This is similar to the GEQRF and ORGQR LAPACK routines. + + + + Computes the QR factorization of A. + + On entry, it is the M by N A matrix to factor. On exit, + it is overwritten with the Q matrix of the QR factorization. + The number of rows in the A matrix. + The number of columns in the A matrix. + On exit, A N by N matrix that holds the R matrix of the + QR factorization. + A min(m,n) vector. On exit, contains additional information + to be used by the QR solve routine. + This is similar to the GEQRF and ORGQR LAPACK routines. + + + + Perform calculation of Q or R + + Work array + Index of column in work array + Q or R matrices + The first row in + The last row + The first column + The last column + Number of available CPUs + + + + Generate column from initial matrix to work array + + Work array + Initial matrix + The number of rows in matrix + The first row + Column index + + + + Solves A*X=B for X using QR factorization of A. + + The A matrix. + The number of rows in the A matrix. + The number of columns in the A matrix. + The B matrix. + The number of columns of B. + On exit, the solution matrix. + The type of QR factorization to perform. + Rows must be greater or equal to columns. + + + + Solves A*X=B for X using a previously QR factored matrix. + + The Q matrix obtained by calling . + The R matrix obtained by calling . + The number of rows in the A matrix. + The number of columns in the A matrix. + Contains additional information on Q. Only used for the native solver + and can be null for the managed provider. + The B matrix. + The number of columns of B. + On exit, the solution matrix. + The type of QR factorization to perform. + Rows must be greater or equal to columns. + + + + Computes the singular value decomposition of A. + + Compute the singular U and VT vectors or not. + On entry, the M by N matrix to decompose. On exit, A may be overwritten. + The number of rows in the A matrix. + The number of columns in the A matrix. + The singular values of A in ascending value. + If is true, on exit U contains the left + singular vectors. + If is true, on exit VT contains the transposed + right singular vectors. + This is equivalent to the GESVD LAPACK routine. + + + + Given the Cartesian coordinates (da, db) of a point p, these function return the parameters da, db, c, and s + associated with the Givens rotation that zeros the y-coordinate of the point. + + Provides the x-coordinate of the point p. On exit contains the parameter r associated with the Givens rotation + Provides the y-coordinate of the point p. On exit contains the parameter z associated with the Givens rotation + Contains the parameter c associated with the Givens rotation + Contains the parameter s associated with the Givens rotation + This is equivalent to the DROTG LAPACK routine. + + + + Solves A*X=B for X using the singular value decomposition of A. + + On entry, the M by N matrix to decompose. + The number of rows in the A matrix. + The number of columns in the A matrix. + The B matrix. + The number of columns of B. + On exit, the solution matrix. + + + + Solves A*X=B for X using a previously SVD decomposed matrix. + + The number of rows in the A matrix. + The number of columns in the A matrix. + The s values returned by . + The left singular vectors returned by . + The right singular vectors returned by . + The B matrix. + The number of columns of B. + On exit, the solution matrix. + + + + Computes the eigenvalues and eigenvectors of a matrix. + + Whether the matrix is symmetric or not. + The order of the matrix. + The matrix to decompose. The length of the array must be order * order. + On output, the matrix contains the eigen vectors. The length of the array must be order * order. + On output, the eigen values (λ) of matrix in ascending value. The length of the array must . + On output, the block diagonal eigenvalue matrix. The length of the array must be order * order. + + + + Symmetric Householder reduction to tridiagonal form. + + Data array of matrix V (eigenvectors) + Arrays for internal storage of real parts of eigenvalues + Arrays for internal storage of imaginary parts of eigenvalues + Order of initial matrix + This is derived from the Algol procedures tred2 by + Bowdler, Martin, Reinsch, and Wilkinson, Handbook for + Auto. Comp., Vol.ii-Linear Algebra, and the corresponding + Fortran subroutine in EISPACK. + + + + Symmetric tridiagonal QL algorithm. + + Data array of matrix V (eigenvectors) + Arrays for internal storage of real parts of eigenvalues + Arrays for internal storage of imaginary parts of eigenvalues + Order of initial matrix + This is derived from the Algol procedures tql2, by + Bowdler, Martin, Reinsch, and Wilkinson, Handbook for + Auto. Comp., Vol.ii-Linear Algebra, and the corresponding + Fortran subroutine in EISPACK. + + + + + Nonsymmetric reduction to Hessenberg form. + + Data array of matrix V (eigenvectors) + Array for internal storage of nonsymmetric Hessenberg form. + Order of initial matrix + This is derived from the Algol procedures orthes and ortran, + by Martin and Wilkinson, Handbook for Auto. Comp., + Vol.ii-Linear Algebra, and the corresponding + Fortran subroutines in EISPACK. + + + + Nonsymmetric reduction from Hessenberg to real Schur form. + + Data array of matrix V (eigenvectors) + Array for internal storage of nonsymmetric Hessenberg form. + Arrays for internal storage of real parts of eigenvalues + Arrays for internal storage of imaginary parts of eigenvalues + Order of initial matrix + This is derived from the Algol procedure hqr2, + by Martin and Wilkinson, Handbook for Auto. Comp., + Vol.ii-Linear Algebra, and the corresponding + Fortran subroutine in EISPACK. + + + + + Complex scalar division X/Y. + + Real part of X + Imaginary part of X + Real part of Y + Imaginary part of Y + Division result as a number. + + + + Adds a scaled vector to another: result = y + alpha*x. + + The vector to update. + The value to scale by. + The vector to add to . + The result of the addition. + This is similar to the AXPY BLAS routine. + + + + Scales an array. Can be used to scale a vector and a matrix. + + The scalar. + The values to scale. + This result of the scaling. + This is similar to the SCAL BLAS routine. + + + + Conjugates an array. Can be used to conjugate a vector and a matrix. + + The values to conjugate. + This result of the conjugation. + + + + Computes the dot product of x and y. + + The vector x. + The vector y. + The dot product of x and y. + This is equivalent to the DOT BLAS routine. + + + + Does a point wise add of two arrays z = x + y. This can be used + to add vectors or matrices. + + The array x. + The array y. + The result of the addition. + There is no equivalent BLAS routine, but many libraries + provide optimized (parallel and/or vectorized) versions of this + routine. + + + + Does a point wise subtraction of two arrays z = x - y. This can be used + to subtract vectors or matrices. + + The array x. + The array y. + The result of the subtraction. + There is no equivalent BLAS routine, but many libraries + provide optimized (parallel and/or vectorized) versions of this + routine. + + + + Does a point wise multiplication of two arrays z = x * y. This can be used + to multiple elements of vectors or matrices. + + The array x. + The array y. + The result of the point wise multiplication. + There is no equivalent BLAS routine, but many libraries + provide optimized (parallel and/or vectorized) versions of this + routine. + + + + Does a point wise division of two arrays z = x / y. This can be used + to divide elements of vectors or matrices. + + The array x. + The array y. + The result of the point wise division. + There is no equivalent BLAS routine, but many libraries + provide optimized (parallel and/or vectorized) versions of this + routine. + + + + Does a point wise power of two arrays z = x ^ y. This can be used + to raise elements of vectors or matrices to the powers of another vector or matrix. + + The array x. + The array y. + The result of the point wise power. + There is no equivalent BLAS routine, but many libraries + provide optimized (parallel and/or vectorized) versions of this + routine. + + + + Computes the requested of the matrix. + + The type of norm to compute. + The number of rows. + The number of columns. + The matrix to compute the norm from. + + The requested of the matrix. + + + + + Multiples two matrices. result = x * y + + The x matrix. + The number of rows in the x matrix. + The number of columns in the x matrix. + The y matrix. + The number of rows in the y matrix. + The number of columns in the y matrix. + Where to store the result of the multiplication. + This is a simplified version of the BLAS GEMM routine with alpha + set to 1.0 and beta set to 0.0, and x and y are not transposed. + + + + Multiplies two matrices and updates another with the result. c = alpha*op(a)*op(b) + beta*c + + How to transpose the matrix. + How to transpose the matrix. + The value to scale matrix. + The a matrix. + The number of rows in the matrix. + The number of columns in the matrix. + The b matrix + The number of rows in the matrix. + The number of columns in the matrix. + The value to scale the matrix. + The c matrix. + + + + Computes the LUP factorization of A. P*A = L*U. + + An by matrix. The matrix is overwritten with the + the LU factorization on exit. The lower triangular factor L is stored in under the diagonal of (the diagonal is always 1.0 + for the L factor). The upper triangular factor U is stored on and above the diagonal of . + The order of the square matrix . + On exit, it contains the pivot indices. The size of the array must be . + This is equivalent to the GETRF LAPACK routine. + + + + Computes the inverse of matrix using LU factorization. + + The N by N matrix to invert. Contains the inverse On exit. + The order of the square matrix . + This is equivalent to the GETRF and GETRI LAPACK routines. + + + + Computes the inverse of a previously factored matrix. + + The LU factored N by N matrix. Contains the inverse On exit. + The order of the square matrix . + The pivot indices of . + This is equivalent to the GETRI LAPACK routine. + + + + Solves A*X=B for X using LU factorization. + + The number of columns of B. + The square matrix A. + The order of the square matrix . + On entry the B matrix; on exit the X matrix. + This is equivalent to the GETRF and GETRS LAPACK routines. + + + + Solves A*X=B for X using a previously factored A matrix. + + The number of columns of B. + The factored A matrix. + The order of the square matrix . + The pivot indices of . + On entry the B matrix; on exit the X matrix. + This is equivalent to the GETRS LAPACK routine. + + + + Computes the Cholesky factorization of A. + + On entry, a square, positive definite matrix. On exit, the matrix is overwritten with the + the Cholesky factorization. + The number of rows or columns in the matrix. + This is equivalent to the POTRF LAPACK routine. + + + + Calculate Cholesky step + + Factor matrix + Number of rows + Column start + Total columns + Multipliers calculated previously + Number of available processors + + + + Solves A*X=B for X using Cholesky factorization. + + The square, positive definite matrix A. + The number of rows and columns in A. + On entry the B matrix; on exit the X matrix. + The number of columns in the B matrix. + This is equivalent to the POTRF add POTRS LAPACK routines. + + + + Solves A*X=B for X using a previously factored A matrix. + + The square, positive definite matrix A. + The number of rows and columns in A. + On entry the B matrix; on exit the X matrix. + The number of columns in the B matrix. + This is equivalent to the POTRS LAPACK routine. + + + + Solves A*X=B for X using a previously factored A matrix. + + The square, positive definite matrix A. Has to be different than . + The number of rows and columns in A. + On entry the B matrix; on exit the X matrix. + The column to solve for. + + + + Computes the QR factorization of A. + + On entry, it is the M by N A matrix to factor. On exit, + it is overwritten with the R matrix of the QR factorization. + The number of rows in the A matrix. + The number of columns in the A matrix. + On exit, A M by M matrix that holds the Q matrix of the + QR factorization. + A min(m,n) vector. On exit, contains additional information + to be used by the QR solve routine. + This is similar to the GEQRF and ORGQR LAPACK routines. + + + + Computes the QR factorization of A. + + On entry, it is the M by N A matrix to factor. On exit, + it is overwritten with the Q matrix of the QR factorization. + The number of rows in the A matrix. + The number of columns in the A matrix. + On exit, A N by N matrix that holds the R matrix of the + QR factorization. + A min(m,n) vector. On exit, contains additional information + to be used by the QR solve routine. + This is similar to the GEQRF and ORGQR LAPACK routines. + + + + Perform calculation of Q or R + + Work array + Index of column in work array + Q or R matrices + The first row in + The last row + The first column + The last column + Number of available CPUs + + + + Generate column from initial matrix to work array + + Work array + Initial matrix + The number of rows in matrix + The first row + Column index + + + + Solves A*X=B for X using QR factorization of A. + + The A matrix. + The number of rows in the A matrix. + The number of columns in the A matrix. + The B matrix. + The number of columns of B. + On exit, the solution matrix. + The type of QR factorization to perform. + Rows must be greater or equal to columns. + + + + Solves A*X=B for X using a previously QR factored matrix. + + The Q matrix obtained by calling . + The R matrix obtained by calling . + The number of rows in the A matrix. + The number of columns in the A matrix. + Contains additional information on Q. Only used for the native solver + and can be null for the managed provider. + The B matrix. + The number of columns of B. + On exit, the solution matrix. + The type of QR factorization to perform. + Rows must be greater or equal to columns. + + + + Computes the singular value decomposition of A. + + Compute the singular U and VT vectors or not. + On entry, the M by N matrix to decompose. On exit, A may be overwritten. + The number of rows in the A matrix. + The number of columns in the A matrix. + The singular values of A in ascending value. + If is true, on exit U contains the left + singular vectors. + If is true, on exit VT contains the transposed + right singular vectors. + This is equivalent to the GESVD LAPACK routine. + + + + Given the Cartesian coordinates (da, db) of a point p, these function return the parameters da, db, c, and s + associated with the Givens rotation that zeros the y-coordinate of the point. + + Provides the x-coordinate of the point p. On exit contains the parameter r associated with the Givens rotation + Provides the y-coordinate of the point p. On exit contains the parameter z associated with the Givens rotation + Contains the parameter c associated with the Givens rotation + Contains the parameter s associated with the Givens rotation + This is equivalent to the DROTG LAPACK routine. + + + + Solves A*X=B for X using the singular value decomposition of A. + + On entry, the M by N matrix to decompose. + The number of rows in the A matrix. + The number of columns in the A matrix. + The B matrix. + The number of columns of B. + On exit, the solution matrix. + + + + Solves A*X=B for X using a previously SVD decomposed matrix. + + The number of rows in the A matrix. + The number of columns in the A matrix. + The s values returned by . + The left singular vectors returned by . + The right singular vectors returned by . + The B matrix. + The number of columns of B. + On exit, the solution matrix. + + + + Computes the eigenvalues and eigenvectors of a matrix. + + Whether the matrix is symmetric or not. + The order of the matrix. + The matrix to decompose. The length of the array must be order * order. + On output, the matrix contains the eigen vectors. The length of the array must be order * order. + On output, the eigen values (λ) of matrix in ascending value. The length of the array must . + On output, the block diagonal eigenvalue matrix. The length of the array must be order * order. + + + + Symmetric Householder reduction to tridiagonal form. + + Data array of matrix V (eigenvectors) + Arrays for internal storage of real parts of eigenvalues + Arrays for internal storage of imaginary parts of eigenvalues + Order of initial matrix + This is derived from the Algol procedures tred2 by + Bowdler, Martin, Reinsch, and Wilkinson, Handbook for + Auto. Comp., Vol.ii-Linear Algebra, and the corresponding + Fortran subroutine in EISPACK. + + + + Symmetric tridiagonal QL algorithm. + + Data array of matrix V (eigenvectors) + Arrays for internal storage of real parts of eigenvalues + Arrays for internal storage of imaginary parts of eigenvalues + Order of initial matrix + This is derived from the Algol procedures tql2, by + Bowdler, Martin, Reinsch, and Wilkinson, Handbook for + Auto. Comp., Vol.ii-Linear Algebra, and the corresponding + Fortran subroutine in EISPACK. + + + + + Nonsymmetric reduction to Hessenberg form. + + Data array of matrix V (eigenvectors) + Array for internal storage of nonsymmetric Hessenberg form. + Order of initial matrix + This is derived from the Algol procedures orthes and ortran, + by Martin and Wilkinson, Handbook for Auto. Comp., + Vol.ii-Linear Algebra, and the corresponding + Fortran subroutines in EISPACK. + + + + Nonsymmetric reduction from Hessenberg to real Schur form. + + Data array of matrix V (eigenvectors) + Array for internal storage of nonsymmetric Hessenberg form. + Arrays for internal storage of real parts of eigenvalues + Arrays for internal storage of imaginary parts of eigenvalues + Order of initial matrix + This is derived from the Algol procedure hqr2, + by Martin and Wilkinson, Handbook for Auto. Comp., + Vol.ii-Linear Algebra, and the corresponding + Fortran subroutine in EISPACK. + + + + + Complex scalar division X/Y. + + Real part of X + Imaginary part of X + Real part of Y + Imaginary part of Y + Division result as a number. + + + + Structure option. + + + + + Factorization option. + + + + + Solver step's substitution. + + + + + Solve a system, Ax = b. + + + + + Solve a transposed system, A'x = b + + + + + Solve a conjugate transposed system, A†x = b + + + + + Status values + + + + + The operation was successful. + + + + + Try to find out whether the provider is available, at least in principle. + Verification may still fail if available, but it will certainly fail if unavailable. + + + + + Initialize and verify that the provided is indeed available. If not, fall back to alternatives like the managed provider + + + + + Frees memory buffers, caches and handles allocated in or to the provider. + Does not unload the provider itself, it is still usable afterwards. + + + + + The managed sparse solver provider + + + + + Try to find out whether the provider is available, at least in principle. + Verification may still fail if available, but it will certainly fail if unavailable. + + + + + Initialize and verify that the provided is indeed available. If not, fall back to alternatives like the managed provider + + + + + Frees memory buffers, caches and handles allocated in or to the provider. + Does not unload the provider itself, it is still usable afterwards. + + + + + Optional path to try to load native provider binaries from, + if the provider specific hint path is not set. + If neither is set, Numerics falls back to the provider specific + environment variables, or the default probing paths. + + + + + Gets or sets the sparse solver provider. Consider to use UseNativeMKL or UseManaged instead. + + The linear algebra provider. + + + + Try to use a native provider, if available. + + + + + Use the best provider available. + + + + + Use a specific provider if configured, e.g. using the + "MathNetNumericsDSSProvider" environment variable, + or fall back to the best provider. + + + + + A random number generator based on the class in the .NET library. + + + + + Construct a new random number generator with a random seed. + + Uses and uses the value of + to set whether the instance is thread safe. + + + + Construct a new random number generator with random seed. + + The to use. + Uses the value of to set whether the instance is thread safe. + + + + Construct a new random number generator with random seed. + + Uses + if set to true , the class is thread safe. + + + + Construct a new random number generator with random seed. + + The to use. + if set to true , the class is thread safe. + + + + Fills the elements of a specified array of bytes with random numbers in full range, including zero and 255 (). + + + + + Returns a random double-precision floating point number greater than or equal to 0.0, and less than 1.0. + + + + + Returns a random 32-bit signed integer greater than or equal to zero and less than + + + + + Fills an array with random numbers greater than or equal to 0.0 and less than 1.0. + + Supports being called in parallel from multiple threads. + + + + Returns an array of random numbers greater than or equal to 0.0 and less than 1.0. + + Supports being called in parallel from multiple threads. + + + + Returns an infinite sequence of random numbers greater than or equal to 0.0 and less than 1.0. + + Supports being called in parallel from multiple threads. + + + + Multiplicative congruential generator using a modulus of 2^31-1 and a multiplier of 1132489760. + + + + + Initializes a new instance of the class using + a seed based on time and unique GUIDs. + + + + + Initializes a new instance of the class using + a seed based on time and unique GUIDs. + + if set to true , the class is thread safe. + + + + Initializes a new instance of the class. + + The seed value. + If the seed value is zero, it is set to one. Uses the + value of to + set whether the instance is thread safe. + + + + Initializes a new instance of the class. + + The seed value. + if set to true, the class is thread safe. + + + + Returns a random double-precision floating point number greater than or equal to 0.0, and less than 1.0. + + + + + Fills an array with random numbers greater than or equal to 0.0 and less than 1.0. + + Supports being called in parallel from multiple threads. + + + + Returns an array of random numbers greater than or equal to 0.0 and less than 1.0. + + Supports being called in parallel from multiple threads. + + + + Returns an infinite sequence of random numbers greater than or equal to 0.0 and less than 1.0. + + Supports being called in parallel from multiple threads, but the result must be enumerated from a single thread each. + + + + Multiplicative congruential generator using a modulus of 2^59 and a multiplier of 13^13. + + + + + Initializes a new instance of the class using + a seed based on time and unique GUIDs. + + + + + Initializes a new instance of the class using + a seed based on time and unique GUIDs. + + if set to true , the class is thread safe. + + + + Initializes a new instance of the class. + + The seed value. + If the seed value is zero, it is set to one. Uses the + value of to + set whether the instance is thread safe. + + + + Initializes a new instance of the class. + + The seed value. + The seed is set to 1, if the zero is used as the seed. + if set to true , the class is thread safe. + + + + Returns a random double-precision floating point number greater than or equal to 0.0, and less than 1.0. + + + + + Fills an array with random numbers greater than or equal to 0.0 and less than 1.0. + + Supports being called in parallel from multiple threads. + + + + Returns an array of random numbers greater than or equal to 0.0 and less than 1.0. + + Supports being called in parallel from multiple threads. + + + + Returns an infinite sequence of random numbers greater than or equal to 0.0 and less than 1.0. + + Supports being called in parallel from multiple threads, but the result must be enumerated from a single thread each. + + + + Random number generator using Mersenne Twister 19937 algorithm. + + + + + Mersenne twister constant. + + + + + Mersenne twister constant. + + + + + Mersenne twister constant. + + + + + Mersenne twister constant. + + + + + Mersenne twister constant. + + + + + Mersenne twister constant. + + + + + Mersenne twister constant. + + + + + Mersenne twister constant. + + + + + Mersenne twister constant. + + + + + Initializes a new instance of the class using + a seed based on time and unique GUIDs. + + If the seed value is zero, it is set to one. Uses the + value of to + set whether the instance is thread safe. + + + + Initializes a new instance of the class using + a seed based on time and unique GUIDs. + + if set to true , the class is thread safe. + + + + Initializes a new instance of the class. + + The seed value. + Uses the value of to + set whether the instance is thread safe. + + + + Initializes a new instance of the class. + + The seed value. + if set to true, the class is thread safe. + + + + Default instance, thread-safe. + + + + + Returns a random double-precision floating point number greater than or equal to 0.0, and less than 1.0. + + + + + Returns a random 32-bit signed integer greater than or equal to zero and less than + + + + + Fills the elements of a specified array of bytes with random numbers in full range, including zero and 255 (). + + + + + Fills an array with random numbers greater than or equal to 0.0 and less than 1.0. + + Supports being called in parallel from multiple threads. + + + + Returns an array of random numbers greater than or equal to 0.0 and less than 1.0. + + Supports being called in parallel from multiple threads. + + + + Returns an infinite sequence of random numbers greater than or equal to 0.0 and less than 1.0. + + Supports being called in parallel from multiple threads, but the result must be enumerated from a single thread each. + + + + A 32-bit combined multiple recursive generator with 2 components of order 3. + + Based off of P. L'Ecuyer, "Combined Multiple Recursive Random Number Generators," Operations Research, 44, 5 (1996), 816--822. + + + + + Initializes a new instance of the class using + a seed based on time and unique GUIDs. + + If the seed value is zero, it is set to one. Uses the + value of to + set whether the instance is thread safe. + + + + Initializes a new instance of the class using + a seed based on time and unique GUIDs. + + if set to true , the class is thread safe. + + + + Initializes a new instance of the class. + + The seed value. + If the seed value is zero, it is set to one. Uses the + value of to + set whether the instance is thread safe. + + + + Initializes a new instance of the class. + + The seed value. + if set to true, the class is thread safe. + + + + Returns a random double-precision floating point number greater than or equal to 0.0, and less than 1.0. + + + + + Fills an array with random numbers greater than or equal to 0.0 and less than 1.0. + + Supports being called in parallel from multiple threads. + + + + Returns an array of random numbers greater than or equal to 0.0 and less than 1.0. + + Supports being called in parallel from multiple threads. + + + + Returns an infinite sequence of random numbers greater than or equal to 0.0 and less than 1.0. + + Supports being called in parallel from multiple threads, but the result must be enumerated from a single thread each. + + + + Represents a Parallel Additive Lagged Fibonacci pseudo-random number generator. + + + The type bases upon the implementation in the + Boost Random Number Library. + It uses the modulus 232 and by default the "lags" 418 and 1279. Some popular pairs are presented on + Wikipedia - Lagged Fibonacci generator. + + + + + Default value for the ShortLag + + + + + Default value for the LongLag + + + + + The multiplier to compute a double-precision floating point number [0, 1) + + + + + Initializes a new instance of the class using + a seed based on time and unique GUIDs. + + If the seed value is zero, it is set to one. Uses the + value of to + set whether the instance is thread safe. + + + + Initializes a new instance of the class using + a seed based on time and unique GUIDs. + + if set to true , the class is thread safe. + + + + Initializes a new instance of the class. + + The seed value. + If the seed value is zero, it is set to one. Uses the + value of to + set whether the instance is thread safe. + + + + Initializes a new instance of the class. + + The seed value. + if set to true , the class is thread safe. + + + + Initializes a new instance of the class. + + The seed value. + if set to true, the class is thread safe. + The ShortLag value + TheLongLag value + + + + Gets the short lag of the Lagged Fibonacci pseudo-random number generator. + + + + + Gets the long lag of the Lagged Fibonacci pseudo-random number generator. + + + + + Stores an array of random numbers + + + + + Stores an index for the random number array element that will be accessed next. + + + + + Fills the array with new unsigned random numbers. + + + Generated random numbers are 32-bit unsigned integers greater than or equal to 0 + and less than or equal to . + + + + + Returns a random double-precision floating point number greater than or equal to 0.0, and less than 1.0. + + + + + Returns a random 32-bit signed integer greater than or equal to zero and less than + + + + + Fills an array with random numbers greater than or equal to 0.0 and less than 1.0. + + Supports being called in parallel from multiple threads. + + + + Returns an array of random numbers greater than or equal to 0.0 and less than 1.0. + + Supports being called in parallel from multiple threads. + + + + Returns an infinite sequence of random numbers greater than or equal to 0.0 and less than 1.0. + + Supports being called in parallel from multiple threads, but the result must be enumerated from a single thread each. + + + + This class implements extension methods for the System.Random class. The extension methods generate + pseudo-random distributed numbers for types other than double and int32. + + + + + Fills an array with uniform random numbers greater than or equal to 0.0 and less than 1.0. + + The random number generator. + The array to fill with random values. + + This extension is thread-safe if and only if called on an random number + generator provided by Math.NET Numerics or derived from the RandomSource class. + + + + + Returns an array of uniform random numbers greater than or equal to 0.0 and less than 1.0. + + The random number generator. + The size of the array to fill. + + This extension is thread-safe if and only if called on an random number + generator provided by Math.NET Numerics or derived from the RandomSource class. + + + + + Returns an infinite sequence of uniform random numbers greater than or equal to 0.0 and less than 1.0. + + + This extension is thread-safe if and only if called on an random number + generator provided by Math.NET Numerics or derived from the RandomSource class. + + + + + Returns an array of uniform random bytes. + + The random number generator. + The size of the array to fill. + + This extension is thread-safe if and only if called on an random number + generator provided by Math.NET Numerics or derived from the RandomSource class. + + + + + Fills an array with uniform random 32-bit signed integers greater than or equal to zero and less than . + + The random number generator. + The array to fill with random values. + + This extension is thread-safe if and only if called on an random number + generator provided by Math.NET Numerics or derived from the RandomSource class. + + + + + Fills an array with uniform random 32-bit signed integers within the specified range. + + The random number generator. + The array to fill with random values. + Lower bound, inclusive. + Upper bound, exclusive. + + This extension is thread-safe if and only if called on an random number + generator provided by Math.NET Numerics or derived from the RandomSource class. + + + + + Returns an infinite sequence of uniform random 32-bit signed integers within the specified range. + + + This extension is thread-safe if and only if called on an random number + generator provided by Math.NET Numerics or derived from the RandomSource class. + + + + + Returns an infinite sequence of uniform random within the specified range. + + + This extension is thread-safe if and only if called on an random number + generator provided by Math.NET Numerics or derived from the RandomSource class. + + + + + Returns a nonnegative random number less than . + + The random number generator. + + A 64-bit signed integer greater than or equal to 0, and less than ; that is, + the range of return values includes 0 but not . + + + + This extension is thread-safe if and only if called on an random number + generator provided by Math.NET Numerics or derived from the RandomSource class. + + + + + Returns a random number of the full Int32 range. + + The random number generator. + + A 32-bit signed integer of the full range, including 0, negative numbers, + and . + + + + This extension is thread-safe if and only if called on an random number + generator provided by Math.NET Numerics or derived from the RandomSource class. + + + + + Returns a random number of the full Int64 range. + + The random number generator. + + A 64-bit signed integer of the full range, including 0, negative numbers, + and . + + + + This extension is thread-safe if and only if called on an random number + generator provided by Math.NET Numerics or derived from the RandomSource class. + + + + + Returns a nonnegative decimal floating point random number less than 1.0. + + The random number generator. + + A decimal floating point number greater than or equal to 0.0, and less than 1.0; that is, + the range of return values includes 0.0 but not 1.0. + + + This extension is thread-safe if and only if called on an random number + generator provided by Math.NET Numerics or derived from the RandomSource class. + + + + + Returns a random boolean. + + The random number generator. + + This extension is thread-safe if and only if called on an random number + generator provided by Math.NET Numerics or derived from the RandomSource class. + + + + + Provides a time-dependent seed value, matching the default behavior of System.Random. + WARNING: There is no randomness in this seed and quick repeated calls can cause + the same seed value. Do not use for cryptography! + + + + + Provides a seed based on time and unique GUIDs. + WARNING: There is only low randomness in this seed, but at least quick repeated + calls will result in different seed values. Do not use for cryptography! + + + + + Provides a seed based on an internal random number generator (crypto if available), time and unique GUIDs. + WARNING: There is only medium randomness in this seed, but quick repeated + calls will result in different seed values. Do not use for cryptography! + + + + + Base class for random number generators. This class introduces a layer between + and the Math.NET Numerics random number generators to provide thread safety. + When used directly it use the System.Random as random number source. + + + + + Initializes a new instance of the class using + the value of to set whether + the instance is thread safe or not. + + + + + Initializes a new instance of the class. + + if set to true , the class is thread safe. + Thread safe instances are two and half times slower than non-thread + safe classes. + + + + Fills an array with uniform random numbers greater than or equal to 0.0 and less than 1.0. + + The array to fill with random values. + + + + Returns an array of uniform random numbers greater than or equal to 0.0 and less than 1.0. + + The size of the array to fill. + + + + Returns an infinite sequence of uniform random numbers greater than or equal to 0.0 and less than 1.0. + + + + + Returns a random 32-bit signed integer greater than or equal to zero and less than . + + + + + Returns a random number less then a specified maximum. + + The exclusive upper bound of the random number returned. Range: maxExclusive ≥ 1. + A 32-bit signed integer less than . + is zero or negative. + + + + Returns a random number within a specified range. + + The inclusive lower bound of the random number returned. + The exclusive upper bound of the random number returned. Range: maxExclusive > minExclusive. + + A 32-bit signed integer greater than or equal to and less than ; that is, the range of return values includes but not . If equals , is returned. + + is greater than . + + + + Fills an array with random 32-bit signed integers greater than or equal to zero and less than . + + The array to fill with random values. + + + + Returns an array with random 32-bit signed integers greater than or equal to zero and less than . + + The size of the array to fill. + + + + Fills an array with random numbers within a specified range. + + The array to fill with random values. + The exclusive upper bound of the random number returned. Range: maxExclusive ≥ 1. + + + + Returns an array with random 32-bit signed integers within the specified range. + + The size of the array to fill. + The exclusive upper bound of the random number returned. Range: maxExclusive ≥ 1. + + + + Fills an array with random numbers within a specified range. + + The array to fill with random values. + The inclusive lower bound of the random number returned. + The exclusive upper bound of the random number returned. Range: maxExclusive > minExclusive. + + + + Returns an array with random 32-bit signed integers within the specified range. + + The size of the array to fill. + The inclusive lower bound of the random number returned. + The exclusive upper bound of the random number returned. Range: maxExclusive > minExclusive. + + + + Returns an infinite sequence of random 32-bit signed integers greater than or equal to zero and less than . + + + + + Returns an infinite sequence of random numbers within a specified range. + + The inclusive lower bound of the random number returned. + The exclusive upper bound of the random number returned. Range: maxExclusive > minExclusive. + + + + Fills the elements of a specified array of bytes with random numbers. + + An array of bytes to contain random numbers. + is null. + + + + Returns a random number between 0.0 and 1.0. + + A double-precision floating point number greater than or equal to 0.0, and less than 1.0. + + + + Returns a random double-precision floating point number greater than or equal to 0.0, and less than 1.0. + + + + + Returns a random 32-bit signed integer greater than or equal to zero and less than 2147483647 (). + + + + + Fills the elements of a specified array of bytes with random numbers in full range, including zero and 255 (). + + + + + Returns a random N-bit signed integer greater than or equal to zero and less than 2^N. + N (bit count) is expected to be greater than zero and less than 32 (not verified). + + + + + Returns a random N-bit signed long integer greater than or equal to zero and less than 2^N. + N (bit count) is expected to be greater than zero and less than 64 (not verified). + + + + + Returns a random 32-bit signed integer within the specified range. + + The exclusive upper bound of the random number returned. Range: maxExclusive ≥ 2 (not verified, must be ensured by caller). + + + + Returns a random 32-bit signed integer within the specified range. + + The inclusive lower bound of the random number returned. + The exclusive upper bound of the random number returned. Range: maxExclusive ≥ minExclusive + 2 (not verified, must be ensured by caller). + + + + A random number generator based on the class in the .NET library. + + + + + Construct a new random number generator with a random seed. + + + + + Construct a new random number generator with random seed. + + if set to true , the class is thread safe. + + + + Construct a new random number generator with random seed. + + The seed value. + + + + Construct a new random number generator with random seed. + + The seed value. + if set to true , the class is thread safe. + + + + Default instance, thread-safe. + + + + + Returns a random double-precision floating point number greater than or equal to 0.0, and less than 1.0. + + + + + Returns a random 32-bit signed integer greater than or equal to zero and less than + + + + + Returns a random 32-bit signed integer within the specified range. + + The exclusive upper bound of the random number returned. Range: maxExclusive ≥ 2 (not verified, must be ensured by caller). + + + + Returns a random 32-bit signed integer within the specified range. + + The inclusive lower bound of the random number returned. + The exclusive upper bound of the random number returned. Range: maxExclusive ≥ minExclusive + 2 (not verified, must be ensured by caller). + + + + Fills the elements of a specified array of bytes with random numbers in full range, including zero and 255 (). + + + + + Fill an array with uniform random numbers greater than or equal to 0.0 and less than 1.0. + WARNING: potentially very short random sequence length, can generate repeated partial sequences. + + Parallelized on large length, but also supports being called in parallel from multiple threads + + + + Returns an array of uniform random numbers greater than or equal to 0.0 and less than 1.0. + WARNING: potentially very short random sequence length, can generate repeated partial sequences. + + Parallelized on large length, but also supports being called in parallel from multiple threads + + + + Returns an infinite sequence of uniform random numbers greater than or equal to 0.0 and less than 1.0. + + Supports being called in parallel from multiple threads, but the result must be enumerated from a single thread each. + + + + Fills an array with random numbers greater than or equal to 0.0 and less than 1.0. + + Supports being called in parallel from multiple threads. + + + + Returns an array of random numbers greater than or equal to 0.0 and less than 1.0. + + Supports being called in parallel from multiple threads. + + + + Returns an infinite sequence of random numbers greater than or equal to 0.0 and less than 1.0. + + Supports being called in parallel from multiple threads, but the result must be enumerated from a single thread each. + + + + Wichmann-Hill’s 1982 combined multiplicative congruential generator. + + See: Wichmann, B. A. & Hill, I. D. (1982), "Algorithm AS 183: + An efficient and portable pseudo-random number generator". Applied Statistics 31 (1982) 188-190 + + + + + Initializes a new instance of the class using + a seed based on time and unique GUIDs. + + + + + Initializes a new instance of the class using + a seed based on time and unique GUIDs. + + if set to true , the class is thread safe. + + + + Initializes a new instance of the class. + + The seed value. + If the seed value is zero, it is set to one. Uses the + value of to + set whether the instance is thread safe. + + + + Initializes a new instance of the class. + + The seed value. + The seed is set to 1, if the zero is used as the seed. + if set to true , the class is thread safe. + + + + Returns a random double-precision floating point number greater than or equal to 0.0, and less than 1.0. + + + + + Fills an array with random numbers greater than or equal to 0.0 and less than 1.0. + + Supports being called in parallel from multiple threads. + + + + Returns an array of random numbers greater than or equal to 0.0 and less than 1.0. + + Supports being called in parallel from multiple threads. + + + + Returns an infinite sequence of random numbers greater than or equal to 0.0 and less than 1.0. + + Supports being called in parallel from multiple threads, but the result must be enumerated from a single thread each. + + + + Wichmann-Hill’s 2006 combined multiplicative congruential generator. + + See: Wichmann, B. A. & Hill, I. D. (2006), "Generating good pseudo-random numbers". + Computational Statistics & Data Analysis 51:3 (2006) 1614-1622 + + + + + Initializes a new instance of the class using + a seed based on time and unique GUIDs. + + + + + Initializes a new instance of the class using + a seed based on time and unique GUIDs. + + if set to true , the class is thread safe. + + + + Initializes a new instance of the class. + + The seed value. + If the seed value is zero, it is set to one. Uses the + value of to + set whether the instance is thread safe. + + + + Initializes a new instance of the class. + + The seed value. + The seed is set to 1, if the zero is used as the seed. + if set to true , the class is thread safe. + + + + Returns a random double-precision floating point number greater than or equal to 0.0, and less than 1.0. + + + + + Fills an array with random numbers greater than or equal to 0.0 and less than 1.0. + + Supports being called in parallel from multiple threads. + + + + Returns an array of random numbers greater than or equal to 0.0 and less than 1.0. + + Supports being called in parallel from multiple threads. + + + + Returns an infinite sequence of random numbers greater than or equal to 0.0 and less than 1.0. + + Supports being called in parallel from multiple threads, but the result must be enumerated from a single thread each. + + + + Implements a multiply-with-carry Xorshift pseudo random number generator (RNG) specified in Marsaglia, George. (2003). Xorshift RNGs. + Xn = a * Xn−3 + c mod 2^32 + http://www.jstatsoft.org/v08/i14/paper + + + + + The default value for X1. + + + + + The default value for X2. + + + + + The default value for the multiplier. + + + + + The default value for the carry over. + + + + + The multiplier to compute a double-precision floating point number [0, 1) + + + + + Seed or last but three unsigned random number. + + + + + Last but two unsigned random number. + + + + + Last but one unsigned random number. + + + + + The value of the carry over. + + + + + The multiplier. + + + + + Initializes a new instance of the class using + a seed based on time and unique GUIDs. + + If the seed value is zero, it is set to one. Uses the + value of to + set whether the instance is thread safe. + Uses the default values of: + + a = 916905990 + c = 13579 + X1 = 77465321 + X2 = 362436069 + + + + + Initializes a new instance of the class using + a seed based on time and unique GUIDs. + + The multiply value + The initial carry value. + The initial value if X1. + The initial value if X2. + If the seed value is zero, it is set to one. Uses the + value of to + set whether the instance is thread safe. + Note: must be less than . + + + + + Initializes a new instance of the class using + a seed based on time and unique GUIDs. + + if set to true , the class is thread safe. + + Uses the default values of: + + a = 916905990 + c = 13579 + X1 = 77465321 + X2 = 362436069 + + + + + Initializes a new instance of the class using + a seed based on time and unique GUIDs. + + if set to true , the class is thread safe. + The multiply value + The initial carry value. + The initial value if X1. + The initial value if X2. + must be less than . + + + + Initializes a new instance of the class. + + The seed value. + If the seed value is zero, it is set to one. Uses the + value of to + set whether the instance is thread safe. + Uses the default values of: + + a = 916905990 + c = 13579 + X1 = 77465321 + X2 = 362436069 + + + + + Initializes a new instance of the class. + + The seed value. + If the seed value is zero, it is set to one. Uses the + value of to + set whether the instance is thread safe. + The multiply value + The initial carry value. + The initial value if X1. + The initial value if X2. + must be less than . + + + + Initializes a new instance of the class. + + The seed value. + if set to true, the class is thread safe. + + Uses the default values of: + + a = 916905990 + c = 13579 + X1 = 77465321 + X2 = 362436069 + + + + + Initializes a new instance of the class. + + The seed value. + if set to true, the class is thread safe. + The multiply value + The initial carry value. + The initial value if X1. + The initial value if X2. + must be less than . + + + + Returns a random double-precision floating point number greater than or equal to 0.0, and less than 1.0. + + + + + Returns a random 32-bit signed integer greater than or equal to zero and less than + + + + + Fills the elements of a specified array of bytes with random numbers in full range, including zero and 255 (). + + + + + Fills an array with random numbers greater than or equal to 0.0 and less than 1.0. + + Supports being called in parallel from multiple threads. + + + + Returns an array of random numbers greater than or equal to 0.0 and less than 1.0. + + Supports being called in parallel from multiple threads. + + + + Returns an infinite sequence of random numbers greater than or equal to 0.0 and less than 1.0. + + Supports being called in parallel from multiple threads, but the result must be enumerated from a single thread each. + + + + Xoshiro256** pseudo random number generator. + A random number generator based on the class in the .NET library. + + + This is xoshiro256** 1.0, our all-purpose, rock-solid generator. It has + excellent(sub-ns) speed, a state space(256 bits) that is large enough + for any parallel application, and it passes all tests we are aware of. + + For generating just floating-point numbers, xoshiro256+ is even faster. + + The state must be seeded so that it is not everywhere zero.If you have + a 64-bit seed, we suggest to seed a splitmix64 generator and use its + output to fill s. + + For further details see: + David Blackman & Sebastiano Vigna (2018), "Scrambled Linear Pseudorandom Number Generators". + https://arxiv.org/abs/1805.01407 + + + + + Construct a new random number generator with a random seed. + + + + + Construct a new random number generator with random seed. + + if set to true , the class is thread safe. + + + + Construct a new random number generator with random seed. + + The seed value. + + + + Construct a new random number generator with random seed. + + The seed value. + if set to true , the class is thread safe. + + + + Returns a random double-precision floating point number greater than or equal to 0.0, and less than 1.0. + + + + + Returns a random 32-bit signed integer greater than or equal to zero and less than + + + + + Fills the elements of a specified array of bytes with random numbers in full range, including zero and 255 (). + + + + + Returns a random N-bit signed integer greater than or equal to zero and less than 2^N. + N (bit count) is expected to be greater than zero and less than 32 (not verified). + + + + + Returns a random N-bit signed long integer greater than or equal to zero and less than 2^N. + N (bit count) is expected to be greater than zero and less than 64 (not verified). + + + + + Fills an array with random numbers greater than or equal to 0.0 and less than 1.0. + + Supports being called in parallel from multiple threads. + + + + Returns an array of random numbers greater than or equal to 0.0 and less than 1.0. + + Supports being called in parallel from multiple threads. + + + + Returns an infinite sequence of random numbers greater than or equal to 0.0 and less than 1.0. + + Supports being called in parallel from multiple threads, but the result must be enumerated from a single thread each. + + + + Splitmix64 RNG. + + RNG state. This can take any value, including zero. + A new random UInt64. + + Splitmix64 produces equidistributed outputs, thus if a zero is generated then the + next zero will be after a further 2^64 outputs. + + + + + Bisection root-finding algorithm. + + + + Find a solution of the equation f(x)=0. + The function to find roots from. + Guess for the low value of the range where the root is supposed to be. Will be expanded if needed. + Guess for the high value of the range where the root is supposed to be. Will be expanded if needed. + Desired accuracy. The root will be refined until the accuracy or the maximum number of iterations is reached. Default 1e-8. Must be greater than 0. + Maximum number of iterations. Default 100. + Factor at which to expand the bounds, if needed. Default 1.6. + Maximum number of expand iterations. Default 100. + Returns the root with the specified accuracy. + + + + Find a solution of the equation f(x)=0. + The function to find roots from. + The low value of the range where the root is supposed to be. + The high value of the range where the root is supposed to be. + Desired accuracy. The root will be refined until the accuracy or the maximum number of iterations is reached. Default 1e-8. Must be greater than 0. + Maximum number of iterations. Default 100. + Returns the root with the specified accuracy. + + + + Find a solution of the equation f(x)=0. + The function to find roots from. + The low value of the range where the root is supposed to be. + The high value of the range where the root is supposed to be. + Desired accuracy for both the root and the function value at the root. The root will be refined until the accuracy or the maximum number of iterations is reached. Must be greater than 0. + Maximum number of iterations. Usually 100. + The root that was found, if any. Undefined if the function returns false. + True if a root with the specified accuracy was found, else false. + + + + Algorithm by Brent, Van Wijngaarden, Dekker et al. + Implementation inspired by Press, Teukolsky, Vetterling, and Flannery, "Numerical Recipes in C", 2nd edition, Cambridge University Press + + + + Find a solution of the equation f(x)=0. + The function to find roots from. + Guess for the low value of the range where the root is supposed to be. Will be expanded if needed. + Guess for the high value of the range where the root is supposed to be. Will be expanded if needed. + Desired accuracy. The root will be refined until the accuracy or the maximum number of iterations is reached. Default 1e-8. Must be greater than 0. + Maximum number of iterations. Default 100. + Factor at which to expand the bounds, if needed. Default 1.6. + Maximum number of expand iterations. Default 100. + Returns the root with the specified accuracy. + + + + Find a solution of the equation f(x)=0. + The function to find roots from. + The low value of the range where the root is supposed to be. + The high value of the range where the root is supposed to be. + Desired accuracy. The root will be refined until the accuracy or the maximum number of iterations is reached. Default 1e-8. Must be greater than 0. + Maximum number of iterations. Default 100. + Returns the root with the specified accuracy. + + + + Find a solution of the equation f(x)=0. + The function to find roots from. + The low value of the range where the root is supposed to be. + The high value of the range where the root is supposed to be. + Desired accuracy. The root will be refined until the accuracy or the maximum number of iterations is reached. Must be greater than 0. + Maximum number of iterations. Usually 100. + The root that was found, if any. Undefined if the function returns false. + True if a root with the specified accuracy was found, else false. + + + Helper method useful for preventing rounding errors. + a*sign(b) + + + + Algorithm by Broyden. + Implementation inspired by Press, Teukolsky, Vetterling, and Flannery, "Numerical Recipes in C", 2nd edition, Cambridge University Press + + + + Find a solution of the equation f(x)=0. + The function to find roots from. + Initial guess of the root. + Desired accuracy. The root will be refined until the accuracy or the maximum number of iterations is reached. Default 1e-8. Must be greater than 0. + Maximum number of iterations. Default 100. + Relative step size for calculating the Jacobian matrix at first step. Default 1.0e-4 + Returns the root with the specified accuracy. + + + + Find a solution of the equation f(x)=0. + The function to find roots from. + Initial guess of the root. + Desired accuracy. The root will be refined until the accuracy or the maximum number of iterations is reached. Must be greater than 0. + Maximum number of iterations. Usually 100. + Relative step size for calculating the Jacobian matrix at first step. + The root that was found, if any. Undefined if the function returns false. + True if a root with the specified accuracy was found, else false. + + + Find a solution of the equation f(x)=0. + The function to find roots from. + Initial guess of the root. + Desired accuracy. The root will be refined until the accuracy or the maximum number of iterations is reached. Must be greater than 0. + Maximum number of iterations. Usually 100. + The root that was found, if any. Undefined if the function returns false. + True if a root with the specified accuracy was found, else false. + + + + Helper method to calculate an approximation of the Jacobian. + + The function. + The argument (initial guess). + The result (of initial guess). + Relative step size for calculating the Jacobian. + + + + Finds roots to the cubic equation x^3 + a2*x^2 + a1*x + a0 = 0 + Implements the cubic formula in http://mathworld.wolfram.com/CubicFormula.html + + + + + Q and R are transformed variables. + + + + + n^(1/3) - work around a negative double raised to (1/3) + + + + + Find all real-valued roots of the cubic equation a0 + a1*x + a2*x^2 + x^3 = 0. + Note the special coefficient order ascending by exponent (consistent with polynomials). + + + + + Find all three complex roots of the cubic equation d + c*x + b*x^2 + a*x^3 = 0. + Note the special coefficient order ascending by exponent (consistent with polynomials). + + + + + Pure Newton-Raphson root-finding algorithm without any recovery measures in cases it behaves badly. + The algorithm aborts immediately if the root leaves the bound interval. + + + + + Find a solution of the equation f(x)=0. + The function to find roots from. + The first derivative of the function to find roots from. + The low value of the range where the root is supposed to be. Aborts if it leaves the interval. + The high value of the range where the root is supposed to be. Aborts if it leaves the interval. + Desired accuracy. The root will be refined until the accuracy or the maximum number of iterations is reached. Default 1e-8. Must be greater than 0. + Maximum number of iterations. Default 100. + Returns the root with the specified accuracy. + + + + Find a solution of the equation f(x)=0. + The function to find roots from. + The first derivative of the function to find roots from. + Initial guess of the root. + The low value of the range where the root is supposed to be. Aborts if it leaves the interval. Default MinValue. + The high value of the range where the root is supposed to be. Aborts if it leaves the interval. Default MaxValue. + Desired accuracy. The root will be refined until the accuracy or the maximum number of iterations is reached. Default 1e-8. Must be greater than 0. + Maximum number of iterations. Default 100. + Returns the root with the specified accuracy. + + + + Find a solution of the equation f(x)=0. + The function to find roots from. + The first derivative of the function to find roots from. + Initial guess of the root. + The low value of the range where the root is supposed to be. Aborts if it leaves the interval. + The high value of the range where the root is supposed to be. Aborts if it leaves the interval. + Desired accuracy. The root will be refined until the accuracy or the maximum number of iterations is reached. Example: 1e-14. Must be greater than 0. + Maximum number of iterations. Example: 100. + The root that was found, if any. Undefined if the function returns false. + True if a root with the specified accuracy was found, else false. + + + + Robust Newton-Raphson root-finding algorithm that falls back to bisection when overshooting or converging too slow, or to subdivision on lacking bracketing. + + + + + Find a solution of the equation f(x)=0. + The function to find roots from. + The first derivative of the function to find roots from. + The low value of the range where the root is supposed to be. + The high value of the range where the root is supposed to be. + Desired accuracy. The root will be refined until the accuracy or the maximum number of iterations is reached. Default 1e-8. Must be greater than 0. + Maximum number of iterations. Default 100. + How many parts an interval should be split into for zero crossing scanning in case of lacking bracketing. Default 20. + Returns the root with the specified accuracy. + + + + Find a solution of the equation f(x)=0. + The function to find roots from. + The first derivative of the function to find roots from. + The low value of the range where the root is supposed to be. + The high value of the range where the root is supposed to be. + Desired accuracy. The root will be refined until the accuracy or the maximum number of iterations is reached. Example: 1e-14. Must be greater than 0. + Maximum number of iterations. Example: 100. + How many parts an interval should be split into for zero crossing scanning in case of lacking bracketing. Example: 20. + The root that was found, if any. Undefined if the function returns false. + True if a root with the specified accuracy was found, else false. + + + + Pure Secant root-finding algorithm without any recovery measures in cases it behaves badly. + The algorithm aborts immediately if the root leaves the bound interval. + + + + + Find a solution of the equation f(x)=0. + The function to find roots from. + The first guess of the root within the bounds specified. + The second guess of the root within the bounds specified. + The low value of the range where the root is supposed to be. Aborts if it leaves the interval. Default MinValue. + The high value of the range where the root is supposed to be. Aborts if it leaves the interval. Default MaxValue. + Desired accuracy. The root will be refined until the accuracy or the maximum number of iterations is reached. Default 1e-8. Must be greater than 0. + Maximum number of iterations. Default 100. + Returns the root with the specified accuracy. + + + + Find a solution of the equation f(x)=0. + The function to find roots from. + The first guess of the root within the bounds specified. + The second guess of the root within the bounds specified. + The low value of the range where the root is supposed to be. Aborts if it leaves the interval. + The low value of the range where the root is supposed to be. Aborts if it leaves the interval. + Desired accuracy. The root will be refined until the accuracy or the maximum number of iterations is reached. Example: 1e-14. Must be greater than 0. + Maximum number of iterations. Example: 100. + The root that was found, if any. Undefined if the function returns false. + True if a root with the specified accuracy was found, else false + + + Detect a range containing at least one root. + The function to detect roots from. + Lower value of the range. + Upper value of the range + The growing factor of research. Usually 1.6. + Maximum number of iterations. Usually 50. + True if the bracketing operation succeeded, false otherwise. + This iterative methods stops when two values with opposite signs are found. + + + + Numerically stable series summation (stops automatically). + + provides the summands sequentially + Sum + + + + Numerically stable series summation (stops automatically). + + provides the summands sequentially + Sum + + + + Sorting algorithms for single, tuple and triple lists. + + + + + Sort a list of keys, in place using the quick sort algorithm using the quick sort algorithm. + + The type of elements in the key list. + List to sort. + Comparison, defining the sort order. + + + + Sort a list of keys and items with respect to the keys, in place using the quick sort algorithm. + + The type of elements in the key list. + The type of elements in the item list. + List to sort. + List to permute the same way as the key list. + Comparison, defining the sort order. + + + + Sort a list of keys, items1 and items2 with respect to the keys, in place using the quick sort algorithm. + + The type of elements in the key list. + The type of elements in the first item list. + The type of elements in the second item list. + List to sort. + First list to permute the same way as the key list. + Second list to permute the same way as the key list. + Comparison, defining the sort order. + + + + Sort a range of a list of keys, in place using the quick sort algorithm. + + The type of element in the list. + List to sort. + The zero-based starting index of the range to sort. + The length of the range to sort. + Comparison, defining the sort order. + + + + Sort a list of keys and items with respect to the keys, in place using the quick sort algorithm. + + The type of elements in the key list. + The type of elements in the item list. + List to sort. + List to permute the same way as the key list. + The zero-based starting index of the range to sort. + The length of the range to sort. + Comparison, defining the sort order. + + + + Sort a list of keys, items1 and items2 with respect to the keys, in place using the quick sort algorithm. + + The type of elements in the key list. + The type of elements in the first item list. + The type of elements in the second item list. + List to sort. + First list to permute the same way as the key list. + Second list to permute the same way as the key list. + The zero-based starting index of the range to sort. + The length of the range to sort. + Comparison, defining the sort order. + + + + Sort a list of keys and items with respect to the keys, in place using the quick sort algorithm. + + The type of elements in the primary list. + The type of elements in the secondary list. + List to sort. + List to sort on duplicate primary items, and permute the same way as the key list. + Comparison, defining the primary sort order. + Comparison, defining the secondary sort order. + + + + Recursive implementation for an in place quick sort on a list. + + The type of the list on which the quick sort is performed. + The list which is sorted using quick sort. + The method with which to compare two elements of the quick sort. + The left boundary of the quick sort. + The right boundary of the quick sort. + + + + Recursive implementation for an in place quick sort on a list while reordering one other list accordingly. + + The type of the list on which the quick sort is performed. + The type of the list which is automatically reordered accordingly. + The list which is sorted using quick sort. + The list which is automatically reordered accordingly. + The method with which to compare two elements of the quick sort. + The left boundary of the quick sort. + The right boundary of the quick sort. + + + + Recursive implementation for an in place quick sort on one list while reordering two other lists accordingly. + + The type of the list on which the quick sort is performed. + The type of the first list which is automatically reordered accordingly. + The type of the second list which is automatically reordered accordingly. + The list which is sorted using quick sort. + The first list which is automatically reordered accordingly. + The second list which is automatically reordered accordingly. + The method with which to compare two elements of the quick sort. + The left boundary of the quick sort. + The right boundary of the quick sort. + + + + Recursive implementation for an in place quick sort on the primary and then by the secondary list while reordering one secondary list accordingly. + + The type of the primary list. + The type of the secondary list. + The list which is sorted using quick sort. + The list which is sorted secondarily (on primary duplicates) and automatically reordered accordingly. + The method with which to compare two elements of the primary list. + The method with which to compare two elements of the secondary list. + The left boundary of the quick sort. + The right boundary of the quick sort. + + + + Performs an in place swap of two elements in a list. + + The type of elements stored in the list. + The list in which the elements are stored. + The index of the first element of the swap. + The index of the second element of the swap. + + + + This partial implementation of the SpecialFunctions class contains all methods related to the Airy functions. + + + This partial implementation of the SpecialFunctions class contains all methods related to the Bessel functions. + + + This partial implementation of the SpecialFunctions class contains all methods related to the error function. + + + This partial implementation of the SpecialFunctions class contains all methods related to the Hankel function. + + + This partial implementation of the SpecialFunctions class contains all methods related to the harmonic function. + + + This partial implementation of the SpecialFunctions class contains all methods related to the modified Bessel function. + + + This partial implementation of the SpecialFunctions class contains all methods related to the log1p function. + + + This partial implementation of the SpecialFunctions class contains all methods related to the logistic function. + + + This partial implementation of the SpecialFunctions class contains all methods related to the Marcum-Q functions. + + + This partial implementation of the SpecialFunctions class contains all methods related to the modified Bessel function. + + + This partial implementation of the SpecialFunctions class contains all methods related to the modified Bessel function. + + + This partial implementation of the SpecialFunctions class contains all methods related to the spherical Bessel functions. + + + + + Returns the Airy function Ai. + AiryAi(z) is a solution to the Airy equation, y'' - y * z = 0. + + The value to compute the Airy function of. + The Airy function Ai. + + + + Returns the exponentially scaled Airy function Ai. + ScaledAiryAi(z) is given by Exp(zta) * AiryAi(z), where zta = (2/3) * z * Sqrt(z). + + The value to compute the Airy function of. + The exponentially scaled Airy function Ai. + + + + Returns the Airy function Ai. + AiryAi(z) is a solution to the Airy equation, y'' - y * z = 0. + + The value to compute the Airy function of. + The Airy function Ai. + + + + Returns the exponentially scaled Airy function Ai. + ScaledAiryAi(z) is given by Exp(zta) * AiryAi(z), where zta = (2/3) * z * Sqrt(z). + + The value to compute the Airy function of. + The exponentially scaled Airy function Ai. + + + + Returns the derivative of the Airy function Ai. + AiryAiPrime(z) is defined as d/dz AiryAi(z). + + The value to compute the derivative of the Airy function of. + The derivative of the Airy function Ai. + + + + Returns the exponentially scaled derivative of Airy function Ai + ScaledAiryAiPrime(z) is given by Exp(zta) * AiryAiPrime(z), where zta = (2/3) * z * Sqrt(z). + + The value to compute the derivative of the Airy function of. + The exponentially scaled derivative of Airy function Ai. + + + + Returns the derivative of the Airy function Ai. + AiryAiPrime(z) is defined as d/dz AiryAi(z). + + The value to compute the derivative of the Airy function of. + The derivative of the Airy function Ai. + + + + Returns the exponentially scaled derivative of the Airy function Ai. + ScaledAiryAiPrime(z) is given by Exp(zta) * AiryAiPrime(z), where zta = (2/3) * z * Sqrt(z). + + The value to compute the derivative of the Airy function of. + The exponentially scaled derivative of the Airy function Ai. + + + + Returns the Airy function Bi. + AiryBi(z) is a solution to the Airy equation, y'' - y * z = 0. + + The value to compute the Airy function of. + The Airy function Bi. + + + + Returns the exponentially scaled Airy function Bi. + ScaledAiryBi(z) is given by Exp(-Abs(zta.Real)) * AiryBi(z) where zta = (2 / 3) * z * Sqrt(z). + + The value to compute the Airy function of. + The exponentially scaled Airy function Bi(z). + + + + Returns the Airy function Bi. + AiryBi(z) is a solution to the Airy equation, y'' - y * z = 0. + + The value to compute the Airy function of. + The Airy function Bi. + + + + Returns the exponentially scaled Airy function Bi. + ScaledAiryBi(z) is given by Exp(-Abs(zta.Real)) * AiryBi(z) where zta = (2 / 3) * z * Sqrt(z). + + The value to compute the Airy function of. + The exponentially scaled Airy function Bi. + + + + Returns the derivative of the Airy function Bi. + AiryBiPrime(z) is defined as d/dz AiryBi(z). + + The value to compute the derivative of the Airy function of. + The derivative of the Airy function Bi. + + + + Returns the exponentially scaled derivative of the Airy function Bi. + ScaledAiryBiPrime(z) is given by Exp(-Abs(zta.Real)) * AiryBiPrime(z) where zta = (2 / 3) * z * Sqrt(z). + + The value to compute the derivative of the Airy function of. + The exponentially scaled derivative of the Airy function Bi. + + + + Returns the derivative of the Airy function Bi. + AiryBiPrime(z) is defined as d/dz AiryBi(z). + + The value to compute the derivative of the Airy function of. + The derivative of the Airy function Bi. + + + + Returns the exponentially scaled derivative of the Airy function Bi. + ScaledAiryBiPrime(z) is given by Exp(-Abs(zta.Real)) * AiryBiPrime(z) where zta = (2 / 3) * z * Sqrt(z). + + The value to compute the derivative of the Airy function of. + The exponentially scaled derivative of the Airy function Bi. + + + + Returns the Bessel function of the first kind. + BesselJ(n, z) is a solution to the Bessel differential equation. + + The order of the Bessel function. + The value to compute the Bessel function of. + The Bessel function of the first kind. + + + + Returns the exponentially scaled Bessel function of the first kind. + ScaledBesselJ(n, z) is given by Exp(-Abs(z.Imaginary)) * BesselJ(n, z). + + The order of the Bessel function. + The value to compute the Bessel function of. + The exponentially scaled Bessel function of the first kind. + + + + Returns the Bessel function of the first kind. + BesselJ(n, z) is a solution to the Bessel differential equation. + + The order of the Bessel function. + The value to compute the Bessel function of. + The Bessel function of the first kind. + + + + Returns the exponentially scaled Bessel function of the first kind. + ScaledBesselJ(n, z) is given by Exp(-Abs(z.Imaginary)) * BesselJ(n, z). + + The order of the Bessel function. + The value to compute the Bessel function of. + The exponentially scaled Bessel function of the first kind. + + + + Returns the Bessel function of the second kind. + BesselY(n, z) is a solution to the Bessel differential equation. + + The order of the Bessel function. + The value to compute the Bessel function of. + The Bessel function of the second kind. + + + + Returns the exponentially scaled Bessel function of the second kind. + ScaledBesselY(n, z) is given by Exp(-Abs(z.Imaginary)) * Y(n, z). + + The order of the Bessel function. + The value to compute the Bessel function of. + The exponentially scaled Bessel function of the second kind. + + + + Returns the Bessel function of the second kind. + BesselY(n, z) is a solution to the Bessel differential equation. + + The order of the Bessel function. + The value to compute the Bessel function of. + The Bessel function of the second kind. + + + + Returns the exponentially scaled Bessel function of the second kind. + ScaledBesselY(n, z) is given by Exp(-Abs(z.Imaginary)) * BesselY(n, z). + + The order of the Bessel function. + The value to compute the Bessel function of. + The exponentially scaled Bessel function of the second kind. + + + + Returns the modified Bessel function of the first kind. + BesselI(n, z) is a solution to the modified Bessel differential equation. + + The order of the modified Bessel function. + The value to compute the modified Bessel function of. + The modified Bessel function of the first kind. + + + + Returns the exponentially scaled modified Bessel function of the first kind. + ScaledBesselI(n, z) is given by Exp(-Abs(z.Real)) * BesselI(n, z). + + The order of the modified Bessel function. + The value to compute the modified Bessel function of. + The exponentially scaled modified Bessel function of the first kind. + + + + Returns the modified Bessel function of the first kind. + BesselI(n, z) is a solution to the modified Bessel differential equation. + + The order of the modified Bessel function. + The value to compute the modified Bessel function of. + The modified Bessel function of the first kind. + + + + Returns the exponentially scaled modified Bessel function of the first kind. + ScaledBesselI(n, z) is given by Exp(-Abs(z.Real)) * BesselI(n, z). + + The order of the modified Bessel function. + The value to compute the modified Bessel function of. + The exponentially scaled modified Bessel function of the first kind. + + + + Returns the modified Bessel function of the second kind. + BesselK(n, z) is a solution to the modified Bessel differential equation. + + The order of the modified Bessel function. + The value to compute the modified Bessel function of. + The modified Bessel function of the second kind. + + + + Returns the exponentially scaled modified Bessel function of the second kind. + ScaledBesselK(n, z) is given by Exp(z) * BesselK(n, z). + + The order of the modified Bessel function. + The value to compute the modified Bessel function of. + The exponentially scaled modified Bessel function of the second kind. + + + + Returns the modified Bessel function of the second kind. + BesselK(n, z) is a solution to the modified Bessel differential equation. + + The order of the modified Bessel function. + The value to compute the modified Bessel function of. + The modified Bessel function of the second kind. + + + + Returns the exponentially scaled modified Bessel function of the second kind. + ScaledBesselK(n, z) is given by Exp(z) * BesselK(n, z). + + The order of the modified Bessel function. + The value to compute the modified Bessel function of. + The exponentially scaled modified Bessel function of the second kind. + + + + Computes the logarithm of the Euler Beta function. + + The first Beta parameter, a positive real number. + The second Beta parameter, a positive real number. + The logarithm of the Euler Beta function evaluated at z,w. + If or are not positive. + + + + Computes the Euler Beta function. + + The first Beta parameter, a positive real number. + The second Beta parameter, a positive real number. + The Euler Beta function evaluated at z,w. + If or are not positive. + + + + Returns the lower incomplete (unregularized) beta function + B(a,b,x) = int(t^(a-1)*(1-t)^(b-1),t=0..x) for real a > 0, b > 0, 1 >= x >= 0. + + The first Beta parameter, a positive real number. + The second Beta parameter, a positive real number. + The upper limit of the integral. + The lower incomplete (unregularized) beta function. + + + + Returns the regularized lower incomplete beta function + I_x(a,b) = 1/Beta(a,b) * int(t^(a-1)*(1-t)^(b-1),t=0..x) for real a > 0, b > 0, 1 >= x >= 0. + + The first Beta parameter, a positive real number. + The second Beta parameter, a positive real number. + The upper limit of the integral. + The regularized lower incomplete beta function. + + + + ************************************** + COEFFICIENTS FOR METHOD ErfImp * + ************************************** + + Polynomial coefficients for a numerator of ErfImp + calculation for Erf(x) in the interval [1e-10, 0.5]. + + + + Polynomial coefficients for a denominator of ErfImp + calculation for Erf(x) in the interval [1e-10, 0.5]. + + + + Polynomial coefficients for a numerator in ErfImp + calculation for Erfc(x) in the interval [0.5, 0.75]. + + + + Polynomial coefficients for a denominator in ErfImp + calculation for Erfc(x) in the interval [0.5, 0.75]. + + + + Polynomial coefficients for a numerator in ErfImp + calculation for Erfc(x) in the interval [0.75, 1.25]. + + + + Polynomial coefficients for a denominator in ErfImp + calculation for Erfc(x) in the interval [0.75, 1.25]. + + + + Polynomial coefficients for a numerator in ErfImp + calculation for Erfc(x) in the interval [1.25, 2.25]. + + + + Polynomial coefficients for a denominator in ErfImp + calculation for Erfc(x) in the interval [1.25, 2.25]. + + + + Polynomial coefficients for a numerator in ErfImp + calculation for Erfc(x) in the interval [2.25, 3.5]. + + + + Polynomial coefficients for a denominator in ErfImp + calculation for Erfc(x) in the interval [2.25, 3.5]. + + + + Polynomial coefficients for a numerator in ErfImp + calculation for Erfc(x) in the interval [3.5, 5.25]. + + + + Polynomial coefficients for a denominator in ErfImp + calculation for Erfc(x) in the interval [3.5, 5.25]. + + + + Polynomial coefficients for a numerator in ErfImp + calculation for Erfc(x) in the interval [5.25, 8]. + + + + Polynomial coefficients for a denominator in ErfImp + calculation for Erfc(x) in the interval [5.25, 8]. + + + + Polynomial coefficients for a numerator in ErfImp + calculation for Erfc(x) in the interval [8, 11.5]. + + + + Polynomial coefficients for a denominator in ErfImp + calculation for Erfc(x) in the interval [8, 11.5]. + + + + Polynomial coefficients for a numerator in ErfImp + calculation for Erfc(x) in the interval [11.5, 17]. + + + + Polynomial coefficients for a denominator in ErfImp + calculation for Erfc(x) in the interval [11.5, 17]. + + + + Polynomial coefficients for a numerator in ErfImp + calculation for Erfc(x) in the interval [17, 24]. + + + + Polynomial coefficients for a denominator in ErfImp + calculation for Erfc(x) in the interval [17, 24]. + + + + Polynomial coefficients for a numerator in ErfImp + calculation for Erfc(x) in the interval [24, 38]. + + + + Polynomial coefficients for a denominator in ErfImp + calculation for Erfc(x) in the interval [24, 38]. + + + + Polynomial coefficients for a numerator in ErfImp + calculation for Erfc(x) in the interval [38, 60]. + + + + Polynomial coefficients for a denominator in ErfImp + calculation for Erfc(x) in the interval [38, 60]. + + + + Polynomial coefficients for a numerator in ErfImp + calculation for Erfc(x) in the interval [60, 85]. + + + + Polynomial coefficients for a denominator in ErfImp + calculation for Erfc(x) in the interval [60, 85]. + + + + Polynomial coefficients for a numerator in ErfImp + calculation for Erfc(x) in the interval [85, 110]. + + + + Polynomial coefficients for a denominator in ErfImp + calculation for Erfc(x) in the interval [85, 110]. + + + + + ************************************** + COEFFICIENTS FOR METHOD ErfInvImp * + ************************************** + + Polynomial coefficients for a numerator of ErfInvImp + calculation for Erf^-1(z) in the interval [0, 0.5]. + + + + Polynomial coefficients for a denominator of ErfInvImp + calculation for Erf^-1(z) in the interval [0, 0.5]. + + + + Polynomial coefficients for a numerator of ErfInvImp + calculation for Erf^-1(z) in the interval [0.5, 0.75]. + + + + Polynomial coefficients for a denominator of ErfInvImp + calculation for Erf^-1(z) in the interval [0.5, 0.75]. + + + + Polynomial coefficients for a numerator of ErfInvImp + calculation for Erf^-1(z) in the interval [0.75, 1] with x less than 3. + + + + Polynomial coefficients for a denominator of ErfInvImp + calculation for Erf^-1(z) in the interval [0.75, 1] with x less than 3. + + + + Polynomial coefficients for a numerator of ErfInvImp + calculation for Erf^-1(z) in the interval [0.75, 1] with x between 3 and 6. + + + + Polynomial coefficients for a denominator of ErfInvImp + calculation for Erf^-1(z) in the interval [0.75, 1] with x between 3 and 6. + + + + Polynomial coefficients for a numerator of ErfInvImp + calculation for Erf^-1(z) in the interval [0.75, 1] with x between 6 and 18. + + + + Polynomial coefficients for a denominator of ErfInvImp + calculation for Erf^-1(z) in the interval [0.75, 1] with x between 6 and 18. + + + + Polynomial coefficients for a numerator of ErfInvImp + calculation for Erf^-1(z) in the interval [0.75, 1] with x between 18 and 44. + + + + Polynomial coefficients for a denominator of ErfInvImp + calculation for Erf^-1(z) in the interval [0.75, 1] with x between 18 and 44. + + + + Polynomial coefficients for a numerator of ErfInvImp + calculation for Erf^-1(z) in the interval [0.75, 1] with x greater than 44. + + + + Polynomial coefficients for a denominator of ErfInvImp + calculation for Erf^-1(z) in the interval [0.75, 1] with x greater than 44. + + + + Calculates the error function. + The value to evaluate. + the error function evaluated at given value. + + + returns 1 if x == double.PositiveInfinity. + returns -1 if x == double.NegativeInfinity. + + + + + Calculates the complementary error function. + The value to evaluate. + the complementary error function evaluated at given value. + + + returns 0 if x == double.PositiveInfinity. + returns 2 if x == double.NegativeInfinity. + + + + + Calculates the inverse error function evaluated at z. + The inverse error function evaluated at given value. + + + returns double.PositiveInfinity if z >= 1.0. + returns double.NegativeInfinity if z <= -1.0. + + + Calculates the inverse error function evaluated at z. + value to evaluate. + the inverse error function evaluated at Z. + + + + Implementation of the error function. + + Where to evaluate the error function. + Whether to compute 1 - the error function. + the error function. + + + Calculates the complementary inverse error function evaluated at z. + The complementary inverse error function evaluated at given value. + We have tested this implementation against the arbitrary precision mpmath library + and found cases where we can only guarantee 9 significant figures correct. + + returns double.PositiveInfinity if z <= 0.0. + returns double.NegativeInfinity if z >= 2.0. + + + calculates the complementary inverse error function evaluated at z. + value to evaluate. + the complementary inverse error function evaluated at Z. + + + + The implementation of the inverse error function. + + First intermediate parameter. + Second intermediate parameter. + Third intermediate parameter. + the inverse error function. + + + + Numerically stable exponential minus one, i.e. x -> exp(x)-1 + + A number specifying a power. + Returns exp(power)-1. + + + + Numerically stable exponential minus one, i.e. x -> exp(x)-1 + + A number specifying a power. + Returns exp(power)-1. + + + + Computes the generalized Exponential Integral function (En). + + The argument of the Exponential Integral function. + Integer power of the denominator term. Generalization index. + The value of the Exponential Integral function. + + This implementation of the computation of the Exponential Integral function follows the derivation in + "Handbook of Mathematical Functions, Applied Mathematics Series, Volume 55", Abramowitz, M., and Stegun, I.A. 1964, reprinted 1968 by + Dover Publications, New York), Chapters 6, 7, and 26. + AND + "Advanced mathematical methods for scientists and engineers", Bender, Carl M.; Steven A. Orszag (1978). page 253 + + + for x > 1 uses continued fraction approach that is often used to compute incomplete gamma. + for 0 < x <= 1 uses Taylor series expansion + + Our unit tests suggest that the accuracy of the Exponential Integral function is correct up to 13 floating point digits. + + + + + Computes the factorial function x -> x! of an integer number > 0. The function can represent all number up + to 22! exactly, all numbers up to 170! using a double representation. All larger values will overflow. + + A value value! for value > 0 + + If you need to multiply or divide various such factorials, consider using the logarithmic version + instead so you can add instead of multiply and subtract instead of divide, and + then exponentiate the result using . This will also circumvent the problem that + factorials become very large even for small parameters. + + + + + + Computes the factorial of an integer. + + + + + Computes the logarithmic factorial function x -> ln(x!) of an integer number > 0. + + A value value! for value > 0 + + + + Computes the binomial coefficient: n choose k. + + A nonnegative value n. + A nonnegative value h. + The binomial coefficient: n choose k. + + + + Computes the natural logarithm of the binomial coefficient: ln(n choose k). + + A nonnegative value n. + A nonnegative value h. + The logarithmic binomial coefficient: ln(n choose k). + + + + Computes the multinomial coefficient: n choose n1, n2, n3, ... + + A nonnegative value n. + An array of nonnegative values that sum to . + The multinomial coefficient. + if is . + If or any of the are negative. + If the sum of all is not equal to . + + + + The order of the approximation. + + + + + Auxiliary variable when evaluating the function. + + + + + Polynomial coefficients for the approximation. + + + + + Computes the logarithm of the Gamma function. + + The argument of the gamma function. + The logarithm of the gamma function. + + This implementation of the computation of the gamma and logarithm of the gamma function follows the derivation in + "An Analysis Of The Lanczos Gamma Approximation", Glendon Ralph Pugh, 2004. + We use the implementation listed on p. 116 which achieves an accuracy of 16 floating point digits. Although 16 digit accuracy + should be sufficient for double values, improving accuracy is possible (see p. 126 in Pugh). + Our unit tests suggest that the accuracy of the Gamma function is correct up to 14 floating point digits. + + + + + Computes the Gamma function. + + The argument of the gamma function. + The logarithm of the gamma function. + + + This implementation of the computation of the gamma and logarithm of the gamma function follows the derivation in + "An Analysis Of The Lanczos Gamma Approximation", Glendon Ralph Pugh, 2004. + We use the implementation listed on p. 116 which should achieve an accuracy of 16 floating point digits. Although 16 digit accuracy + should be sufficient for double values, improving accuracy is possible (see p. 126 in Pugh). + + Our unit tests suggest that the accuracy of the Gamma function is correct up to 13 floating point digits. + + + + + Returns the upper incomplete regularized gamma function + Q(a,x) = 1/Gamma(a) * int(exp(-t)t^(a-1),t=0..x) for real a > 0, x > 0. + + The argument for the gamma function. + The lower integral limit. + The upper incomplete regularized gamma function. + + + + Returns the upper incomplete gamma function + Gamma(a,x) = int(exp(-t)t^(a-1),t=0..x) for real a > 0, x > 0. + + The argument for the gamma function. + The lower integral limit. + The upper incomplete gamma function. + + + + Returns the lower incomplete gamma function + gamma(a,x) = int(exp(-t)t^(a-1),t=0..x) for real a > 0, x > 0. + + The argument for the gamma function. + The upper integral limit. + The lower incomplete gamma function. + + + + Returns the lower incomplete regularized gamma function + P(a,x) = 1/Gamma(a) * int(exp(-t)t^(a-1),t=0..x) for real a > 0, x > 0. + + The argument for the gamma function. + The upper integral limit. + The lower incomplete gamma function. + + + + Returns the inverse P^(-1) of the regularized lower incomplete gamma function + P(a,x) = 1/Gamma(a) * int(exp(-t)t^(a-1),t=0..x) for real a > 0, x > 0, + such that P^(-1)(a,P(a,x)) == x. + + + + + Computes the Digamma function which is mathematically defined as the derivative of the logarithm of the gamma function. + This implementation is based on + Jose Bernardo + Algorithm AS 103: + Psi ( Digamma ) Function, + Applied Statistics, + Volume 25, Number 3, 1976, pages 315-317. + Using the modifications as in Tom Minka's lightspeed toolbox. + + The argument of the digamma function. + The value of the DiGamma function at . + + + + Computes the inverse Digamma function: this is the inverse of the logarithm of the gamma function. This function will + only return solutions that are positive. + This implementation is based on the bisection method. + + The argument of the inverse digamma function. + The positive solution to the inverse DiGamma function at . + + + + Computes the Rising Factorial (Pochhammer function) x -> (x)n, n>= 0. see: https://en.wikipedia.org/wiki/Falling_and_rising_factorials + + The real value of the Rising Factorial for x and n + + + + Computes the Falling Factorial (Pochhammer function) x -> x(n), n>= 0. see: https://en.wikipedia.org/wiki/Falling_and_rising_factorials + + The real value of the Falling Factorial for x and n + + + + A generalized hypergeometric series is a power series in which the ratio of successive coefficients indexed by n is a rational function of n. + This is the most common pFq(a1, ..., ap; b1,...,bq; z) representation + see: https://en.wikipedia.org/wiki/Generalized_hypergeometric_function + + The list of coefficients in the numerator + The list of coefficients in the denominator + The variable in the power series + The value of the Generalized HyperGeometric Function. + + + + Returns the Hankel function of the first kind. + HankelH1(n, z) is defined as BesselJ(n, z) + j * BesselY(n, z). + + The order of the Hankel function. + The value to compute the Hankel function of. + The Hankel function of the first kind. + + + + Returns the exponentially scaled Hankel function of the first kind. + ScaledHankelH1(n, z) is given by Exp(-z * j) * HankelH1(n, z) where j = Sqrt(-1). + + The order of the Hankel function. + The value to compute the Hankel function of. + The exponentially scaled Hankel function of the first kind. + + + + Returns the Hankel function of the second kind. + HankelH2(n, z) is defined as BesselJ(n, z) - j * BesselY(n, z). + + The order of the Hankel function. + The value to compute the Hankel function of. + The Hankel function of the second kind. + + + + Returns the exponentially scaled Hankel function of the second kind. + ScaledHankelH2(n, z) is given by Exp(z * j) * HankelH2(n, z) where j = Sqrt(-1). + + The order of the Hankel function. + The value to compute the Hankel function of. + The exponentially scaled Hankel function of the second kind. + + + + Computes the 'th Harmonic number. + + The Harmonic number which needs to be computed. + The t'th Harmonic number. + + + + Compute the generalized harmonic number of order n of m. (1 + 1/2^m + 1/3^m + ... + 1/n^m) + + The order parameter. + The power parameter. + General Harmonic number. + + + + Returns the Kelvin function of the first kind. + KelvinBe(nu, x) is given by BesselJ(0, j * sqrt(j) * x) where j = sqrt(-1). + KelvinBer(nu, x) and KelvinBei(nu, x) are the real and imaginary parts of the KelvinBe(nu, x) + + the order of the the Kelvin function. + The value to compute the Kelvin function of. + The Kelvin function of the first kind. + + + + Returns the Kelvin function ber. + KelvinBer(nu, x) is given by the real part of BesselJ(nu, j * sqrt(j) * x) where j = sqrt(-1). + + the order of the the Kelvin function. + The value to compute the Kelvin function of. + The Kelvin function ber. + + + + Returns the Kelvin function ber. + KelvinBer(x) is given by the real part of BesselJ(0, j * sqrt(j) * x) where j = sqrt(-1). + KelvinBer(x) is equivalent to KelvinBer(0, x). + + The value to compute the Kelvin function of. + The Kelvin function ber. + + + + Returns the Kelvin function bei. + KelvinBei(nu, x) is given by the imaginary part of BesselJ(nu, j * sqrt(j) * x) where j = sqrt(-1). + + the order of the the Kelvin function. + The value to compute the Kelvin function of. + The Kelvin function bei. + + + + Returns the Kelvin function bei. + KelvinBei(x) is given by the imaginary part of BesselJ(0, j * sqrt(j) * x) where j = sqrt(-1). + KelvinBei(x) is equivalent to KelvinBei(0, x). + + The value to compute the Kelvin function of. + The Kelvin function bei. + + + + Returns the derivative of the Kelvin function ber. + + The order of the Kelvin function. + The value to compute the derivative of the Kelvin function of. + the derivative of the Kelvin function ber + + + + Returns the derivative of the Kelvin function ber. + + The value to compute the derivative of the Kelvin function of. + The derivative of the Kelvin function ber. + + + + Returns the derivative of the Kelvin function bei. + + The order of the Kelvin function. + The value to compute the derivative of the Kelvin function of. + the derivative of the Kelvin function bei. + + + + Returns the derivative of the Kelvin function bei. + + The value to compute the derivative of the Kelvin function of. + The derivative of the Kelvin function bei. + + + + Returns the Kelvin function of the second kind + KelvinKe(nu, x) is given by Exp(-nu * pi * j / 2) * BesselK(nu, x * sqrt(j)) where j = sqrt(-1). + KelvinKer(nu, x) and KelvinKei(nu, x) are the real and imaginary parts of the KelvinBe(nu, x) + + The order of the Kelvin function. + The value to calculate the kelvin function of, + + + + + Returns the Kelvin function ker. + KelvinKer(nu, x) is given by the real part of Exp(-nu * pi * j / 2) * BesselK(nu, sqrt(j) * x) where j = sqrt(-1). + + the order of the the Kelvin function. + The non-negative real value to compute the Kelvin function of. + The Kelvin function ker. + + + + Returns the Kelvin function ker. + KelvinKer(x) is given by the real part of Exp(-nu * pi * j / 2) * BesselK(0, sqrt(j) * x) where j = sqrt(-1). + KelvinKer(x) is equivalent to KelvinKer(0, x). + + The non-negative real value to compute the Kelvin function of. + The Kelvin function ker. + + + + Returns the Kelvin function kei. + KelvinKei(nu, x) is given by the imaginary part of Exp(-nu * pi * j / 2) * BesselK(nu, sqrt(j) * x) where j = sqrt(-1). + + the order of the the Kelvin function. + The non-negative real value to compute the Kelvin function of. + The Kelvin function kei. + + + + Returns the Kelvin function kei. + KelvinKei(x) is given by the imaginary part of Exp(-nu * pi * j / 2) * BesselK(0, sqrt(j) * x) where j = sqrt(-1). + KelvinKei(x) is equivalent to KelvinKei(0, x). + + The non-negative real value to compute the Kelvin function of. + The Kelvin function kei. + + + + Returns the derivative of the Kelvin function ker. + + The order of the Kelvin function. + The non-negative real value to compute the derivative of the Kelvin function of. + The derivative of the Kelvin function ker. + + + + Returns the derivative of the Kelvin function ker. + + The value to compute the derivative of the Kelvin function of. + The derivative of the Kelvin function ker. + + + + Returns the derivative of the Kelvin function kei. + + The order of the Kelvin function. + The value to compute the derivative of the Kelvin function of. + The derivative of the Kelvin function kei. + + + + Returns the derivative of the Kelvin function kei. + + The value to compute the derivative of the Kelvin function of. + The derivative of the Kelvin function kei. + + + + Computes ln(1+x) with good relative precision when |x| is small + + The parameter for which to compute the log1p function. Range: x > 0. + + + + Computes the logistic function. see: http://en.wikipedia.org/wiki/Logistic + + The parameter for which to compute the logistic function. + The logistic function of . + + + + Computes the logit function, the inverse of the sigmoid logistic function. see: http://en.wikipedia.org/wiki/Logit + + The parameter for which to compute the logit function. This number should be + between 0 and 1. + The logarithm of divided by 1.0 - . + + + + Returns the Marcum Q-function Q[ν](a,b). Marcum Q-function (Wikipedia) + References: A. Gil, J. Segura and N.M. Temme. Efficient and accurate algorithms for the + computation and inversion of the incomplete gamma function ratios. SIAM J Sci Comput. (2012) 34(6), A2965-A2981 + + The order of generalized Marcum Q-function. Range: 1≦ν≦10000 + The value to compute the Marcum Q-function of. Range: 0≦a≦10000 + The value to compute the Marcum Q-function of. Range: 0≦b≦10000 + The Marcum Q-function Q[ν](a,b) + + + + Returns the Marcum Q-function Q[ν](a,b). Marcum Q-function (Wikipedia) + References: A. Gil, J. Segura and N.M. Temme. Efficient and accurate algorithms for the + computation and inversion of the incomplete gamma function ratios. SIAM J Sci Comput. (2012) 34(6), A2965-A2981 + + The order of generalized Marcum Q-function. Range: 1≦ν≦10000 + The value to compute the Marcum Q-function of. Range: 0≦a≦10000 + The value to compute the Marcum Q-function of. Range: 0≦b≦10000 + Error flag + 0: Computation succesful. + 1: Underflow problems. The function value is set to one. + 2: Any of the arguments of the function is out of range.The function value is set to zero. + + The Marcum Q-function Q[ν](a,b) + + + + Marcum Q-functions + References + [1] A. Gil, J. Segura and N.M. Temme, Accompanying paper in ACM Trans Math Soft + [2] A. Gil, J. Segura and N.M. Temme. Efficient and accurate algorithms for the + computation and inversion of the incomplete gamma function ratios. SIAM J Sci Comput. + (2012) 34(6), A2965-A2981 + + + + + Fortran 95 TINY(0.0d0) + + + + + Fortran 95 HUGE(0.0d0) + + + + + The number 2**(1/4) + + + + + machine-epsilon + + + + + The number log[e](sqrt(2*pi)) + + + + + Safe underflow limit + + + + + Safe overflow limit + + + + + Lower limit of exponential + + + + + Demanded accuracy + + + + + Calculation of the Marcum Q-functions P_mu(x,y) and Q_mu(x,y). Marcum Q-function (Wikipedia) + + + + In order to avoid, overflow/underflow problems in IEEE double precision arithmetic, the admissible parameter ranges for computation are: + + + 0≦x≦10000, 0≦y≦10000, 1≦mu≦10000 + + + The aimed relative accuracy is close to 1.0e-11 in the previous parameter domain. + + + argument of the functions + argument of the functions + argument of the functions + function P_mu(a,x) + function Q_mu(a,x) + error flag + 0: Computation succesful + 1: Underflow problems. The function values are set to zero and one. + 2: Any of the arguments of the function is out of range.The function values (P_mu(a, x) and Q_mu(a, x)) are set to zero. + + + + + computation of the incomplete gamma function ratios + + + + + Calculation of the incomplete gamma functions ratios P(a,x) and Q(a,x). + + argument of the functions + argument of the functions + function P(a,x) + function Q(a,x) + error flag + + + + Computes xr in the equations P(a,xr)=p and Q(a,xr)=q with a as a given positive parameter. In most cases, we invert the equation with min(p,q) + + argument of the functions + function P(a,x) + function Q(a,x) + soluction of the equations P(a,xr)=p and Q(a,xr)=q with a as a given positive parameter. + error flag + + + + dompart is approx. of x^a * exp(-x) / gamma(a+1) + + argument of the functions + argument of the functions + argument of the functions + + + + + Computation of ln(gamma(x)), x>0 + + argument of the functions + + + + + ************************************** + COEFFICIENTS FOR METHODS bessi0 * + ************************************** + + Chebyshev coefficients for exp(-x) I0(x) + in the interval [0, 8]. + + lim(x->0){ exp(-x) I0(x) } = 1. + + + + Chebyshev coefficients for exp(-x) sqrt(x) I0(x) + in the inverted interval [8, infinity]. + + lim(x->inf){ exp(-x) sqrt(x) I0(x) } = 1/sqrt(2pi). + + + + + ************************************** + COEFFICIENTS FOR METHODS bessi1 * + ************************************** + + Chebyshev coefficients for exp(-x) I1(x) / x + in the interval [0, 8]. + + lim(x->0){ exp(-x) I1(x) / x } = 1/2. + + + + Chebyshev coefficients for exp(-x) sqrt(x) I1(x) + in the inverted interval [8, infinity]. + + lim(x->inf){ exp(-x) sqrt(x) I1(x) } = 1/sqrt(2pi). + + + + + ************************************** + COEFFICIENTS FOR METHODS bessk0, bessk0e * + ************************************** + + Chebyshev coefficients for K0(x) + log(x/2) I0(x) + in the interval [0, 2]. The odd order coefficients are all + zero; only the even order coefficients are listed. + + lim(x->0){ K0(x) + log(x/2) I0(x) } = -EUL. + + + + Chebyshev coefficients for exp(x) sqrt(x) K0(x) + in the inverted interval [2, infinity]. + + lim(x->inf){ exp(x) sqrt(x) K0(x) } = sqrt(pi/2). + + + + + ************************************** + COEFFICIENTS FOR METHODS bessk1, bessk1e * + ************************************** + + Chebyshev coefficients for x(K1(x) - log(x/2) I1(x)) + in the interval [0, 2]. + + lim(x->0){ x(K1(x) - log(x/2) I1(x)) } = 1. + + + + Chebyshev coefficients for exp(x) sqrt(x) K1(x) + in the interval [2, infinity]. + + lim(x->inf){ exp(x) sqrt(x) K1(x) } = sqrt(pi/2). + + + + Returns the modified Bessel function of first kind, order 0 of the argument. +

    + The function is defined as i0(x) = j0( ix ). +

    + The range is partitioned into the two intervals [0, 8] and + (8, infinity). Chebyshev polynomial expansions are employed + in each interval. +

    + The value to compute the Bessel function of. + +     + + Returns the modified Bessel function of first kind, + order 1 of the argument. +

    + The function is defined as i1(x) = -i j1( ix ). +

    + The range is partitioned into the two intervals [0, 8] and + (8, infinity). Chebyshev polynomial expansions are employed + in each interval. +

    + The value to compute the Bessel function of. + +     + + Returns the modified Bessel function of the second kind + of order 0 of the argument. +

    + The range is partitioned into the two intervals [0, 8] and + (8, infinity). Chebyshev polynomial expansions are employed + in each interval. +

    + The value to compute the Bessel function of. + +     + + Returns the exponentially scaled modified Bessel function + of the second kind of order 0 of the argument. + + The value to compute the Bessel function of. + + + + Returns the modified Bessel function of the second kind + of order 1 of the argument. +

    + The range is partitioned into the two intervals [0, 2] and + (2, infinity). Chebyshev polynomial expansions are employed + in each interval. +

    + The value to compute the Bessel function of. + +     + + Returns the exponentially scaled modified Bessel function + of the second kind of order 1 of the argument. +

    + k1e(x) = exp(x) * k1(x). +

    + The value to compute the Bessel function of. + +     + + + Returns the modified Struve function of order 0. + + The value to compute the function of. + + + + Returns the modified Struve function of order 1. + + The value to compute the function of. + + + + Returns the difference between the Bessel I0 and Struve L0 functions. + + The value to compute the function of. + + + + Returns the difference between the Bessel I1 and Struve L1 functions. + + The value to compute the function of. + + + + Returns the spherical Bessel function of the first kind. + SphericalBesselJ(n, z) is given by Sqrt(pi/2) / Sqrt(z) * BesselJ(n + 1/2, z). + + The order of the spherical Bessel function. + The value to compute the spherical Bessel function of. + The spherical Bessel function of the first kind. + + + + Returns the spherical Bessel function of the first kind. + SphericalBesselJ(n, z) is given by Sqrt(pi/2) / Sqrt(z) * BesselJ(n + 1/2, z). + + The order of the spherical Bessel function. + The value to compute the spherical Bessel function of. + The spherical Bessel function of the first kind. + + + + Returns the spherical Bessel function of the second kind. + SphericalBesselY(n, z) is given by Sqrt(pi/2) / Sqrt(z) * BesselY(n + 1/2, z). + + The order of the spherical Bessel function. + The value to compute the spherical Bessel function of. + The spherical Bessel function of the second kind. + + + + Returns the spherical Bessel function of the second kind. + SphericalBesselY(n, z) is given by Sqrt(pi/2) / Sqrt(z) * BesselY(n + 1/2, z). + + The order of the spherical Bessel function. + The value to compute the spherical Bessel function of. + The spherical Bessel function of the second kind. + + + + Numerically stable hypotenuse of a right angle triangle, i.e. (a,b) -> sqrt(a^2 + b^2) + + The length of side a of the triangle. + The length of side b of the triangle. + Returns sqrt(a2 + b2) without underflow/overflow. + + + + Numerically stable hypotenuse of a right angle triangle, i.e. (a,b) -> sqrt(a^2 + b^2) + + The length of side a of the triangle. + The length of side b of the triangle. + Returns sqrt(a2 + b2) without underflow/overflow. + + + + Numerically stable hypotenuse of a right angle triangle, i.e. (a,b) -> sqrt(a^2 + b^2) + + The length of side a of the triangle. + The length of side b of the triangle. + Returns sqrt(a2 + b2) without underflow/overflow. + + + + Numerically stable hypotenuse of a right angle triangle, i.e. (a,b) -> sqrt(a^2 + b^2) + + The length of side a of the triangle. + The length of side b of the triangle. + Returns sqrt(a2 + b2) without underflow/overflow. + + + + Evaluation functions, useful for function approximation. + + + + Evaluates the series of Chebyshev polynomials Ti at argument x/2. + The series is given by + 
    +                  N-1
+                   - '
+            y  =   >   coef[i] T (x/2)
+                   -            i
+                  i=0
+
    + Coefficients are stored in reverse order, i.e. the zero + order term is last in the array. Note N is the number of + coefficients, not the order. +

    + If coefficients are for the interval a to b, x must + have been transformed to x -> 2(2x - b - a)/(b-a) before + entering the routine. This maps x from (a, b) to (-1, 1), + over which the Chebyshev polynomials are defined. +

    + If the coefficients are for the inverted interval, in + which (a, b) is mapped to (1/b, 1/a), the transformation + required is x -> 2(2ab/x - b - a)/(b-a). If b is infinity, + this becomes x -> 4a/x - 1. +

    + SPEED: +

    + Taking advantage of the recurrence properties of the + Chebyshev polynomials, the routine requires one more + addition per loop than evaluating a nested polynomial of + the same degree. +

    + The coefficients of the polynomial. + Argument to the polynomial. + + Reference: https://bpm2.svn.codeplex.com/svn/Common.Numeric/Arithmetic.cs +

    + Marked as Deprecated in + http://people.apache.org/~isabel/mahout_site/mahout-matrix/apidocs/org/apache/mahout/jet/math/Arithmetic.html + + + +

    + Summation of Chebyshev polynomials, using the Clenshaw method with Reinsch modification. + + The no. of terms in the sequence. + The coefficients of the Chebyshev series, length n+1. + The value at which the series is to be evaluated. + + ORIGINAL AUTHOR: + Dr. Allan J. MacLeod; Dept. of Mathematics and Statistics, University of Paisley; High St., PAISLEY, SCOTLAND + REFERENCES: + "An error analysis of the modified Clenshaw method for evaluating Chebyshev and Fourier series" + J. Oliver, J.I.M.A., vol. 20, 1977, pp379-391 + +     + + + Valley-shaped Rosenbrock function for 2 dimensions: (x,y) -> (1-x)^2 + 100*(y-x^2)^2. + This function has a global minimum at (1,1) with f(1,1) = 0. + Common range: [-5,10] or [-2.048,2.048]. + + + https://en.wikipedia.org/wiki/Rosenbrock_function + http://www.sfu.ca/~ssurjano/rosen.html + + + + + Valley-shaped Rosenbrock function for 2 or more dimensions. + This function have a global minimum of all ones and, for 8 > N > 3, a local minimum at (-1,1,...,1). + + + https://en.wikipedia.org/wiki/Rosenbrock_function + http://www.sfu.ca/~ssurjano/rosen.html + + + + + Himmelblau, a multi-modal function: (x,y) -> (x^2+y-11)^2 + (x+y^2-7)^2 + This function has 4 global minima with f(x,y) = 0. + Common range: [-6,6]. + Named after David Mautner Himmelblau + + + https://en.wikipedia.org/wiki/Himmelblau%27s_function + + + + + Rastrigin, a highly multi-modal function with many local minima. + Global minimum of all zeros with f(0) = 0. + Common range: [-5.12,5.12]. + + + https://en.wikipedia.org/wiki/Rastrigin_function + http://www.sfu.ca/~ssurjano/rastr.html + + + + + Drop-Wave, a multi-modal and highly complex function with many local minima. + Global minimum of all zeros with f(0) = -1. + Common range: [-5.12,5.12]. + + + http://www.sfu.ca/~ssurjano/drop.html + + + + + Ackley, a function with many local minima. It is nearly flat in outer regions but has a large hole at the center. + Global minimum of all zeros with f(0) = 0. + Common range: [-32.768, 32.768]. + + + http://www.sfu.ca/~ssurjano/ackley.html + + + + + Bowl-shaped first Bohachevsky function. + Global minimum of all zeros with f(0,0) = 0. + Common range: [-100, 100] + + + http://www.sfu.ca/~ssurjano/boha.html + + + + + Plate-shaped Matyas function. + Global minimum of all zeros with f(0,0) = 0. + Common range: [-10, 10]. + + + http://www.sfu.ca/~ssurjano/matya.html + + + + + Valley-shaped six-hump camel back function. + Two global minima and four local minima. Global minima with f(x) ) -1.0316 at (0.0898,-0.7126) and (-0.0898,0.7126). + Common range: x in [-3,3], y in [-2,2]. + + + http://www.sfu.ca/~ssurjano/camel6.html + + + + + Statistics operating on arrays assumed to be unsorted. + WARNING: Methods with the Inplace-suffix may modify the data array by reordering its entries. + + + + + + + + Returns the smallest absolute value from the unsorted data array. + Returns NaN if data is empty or any entry is NaN. + + Sample array, no sorting is assumed. + + + + Returns the smallest absolute value from the unsorted data array. + Returns NaN if data is empty or any entry is NaN. + + Sample array, no sorting is assumed. + + + + Returns the largest absolute value from the unsorted data array. + Returns NaN if data is empty or any entry is NaN. + + Sample array, no sorting is assumed. + + + + Returns the largest absolute value from the unsorted data array. + Returns NaN if data is empty or any entry is NaN. + + Sample array, no sorting is assumed. + + + + Returns the smallest value from the unsorted data array. + Returns NaN if data is empty or any entry is NaN. + + Sample array, no sorting is assumed. + + + + Returns the largest value from the unsorted data array. + Returns NaN if data is empty or any entry is NaN. + + Sample array, no sorting is assumed. + + + + Returns the smallest absolute value from the unsorted data array. + Returns NaN if data is empty or any entry is NaN. + + Sample array, no sorting is assumed. + + + + Returns the largest absolute value from the unsorted data array. + Returns NaN if data is empty or any entry is NaN. + + Sample array, no sorting is assumed. + + + + Estimates the arithmetic sample mean from the unsorted data array. + Returns NaN if data is empty or any entry is NaN. + + Sample array, no sorting is assumed. + + + + Evaluates the geometric mean of the unsorted data array. + Returns NaN if data is empty or any entry is NaN. + + Sample array, no sorting is assumed. + + + + Evaluates the harmonic mean of the unsorted data array. + Returns NaN if data is empty or any entry is NaN. + + Sample array, no sorting is assumed. + + + + Estimates the unbiased population variance from the provided samples as unsorted array. + On a dataset of size N will use an N-1 normalizer (Bessel's correction). + Returns NaN if data has less than two entries or if any entry is NaN. + + Sample array, no sorting is assumed. + + + + Evaluates the population variance from the full population provided as unsorted array. + On a dataset of size N will use an N normalizer and would thus be biased if applied to a subset. + Returns NaN if data is empty or if any entry is NaN. + + Sample array, no sorting is assumed. + + + + Estimates the unbiased population standard deviation from the provided samples as unsorted array. + On a dataset of size N will use an N-1 normalizer (Bessel's correction). + Returns NaN if data has less than two entries or if any entry is NaN. + + Sample array, no sorting is assumed. + + + + Evaluates the population standard deviation from the full population provided as unsorted array. + On a dataset of size N will use an N normalizer and would thus be biased if applied to a subset. + Returns NaN if data is empty or if any entry is NaN. + + Sample array, no sorting is assumed. + + + + Estimates the arithmetic sample mean and the unbiased population variance from the provided samples as unsorted array. + On a dataset of size N will use an N-1 normalizer (Bessel's correction). + Returns NaN for mean if data is empty or any entry is NaN and NaN for variance if data has less than two entries or if any entry is NaN. + + Sample array, no sorting is assumed. + + + + Estimates the arithmetic sample mean and the unbiased population standard deviation from the provided samples as unsorted array. + On a dataset of size N will use an N-1 normalizer (Bessel's correction). + Returns NaN for mean if data is empty or any entry is NaN and NaN for standard deviation if data has less than two entries or if any entry is NaN. + + Sample array, no sorting is assumed. + + + + Estimates the unbiased population covariance from the provided two sample arrays. + On a dataset of size N will use an N-1 normalizer (Bessel's correction). + Returns NaN if data has less than two entries or if any entry is NaN. + + First sample array. + Second sample array. + + + + Evaluates the population covariance from the full population provided as two arrays. + On a dataset of size N will use an N normalizer and would thus be biased if applied to a subset. + Returns NaN if data is empty or if any entry is NaN. + + First population array. + Second population array. + + + + Estimates the root mean square (RMS) also known as quadratic mean from the unsorted data array. + Returns NaN if data is empty or any entry is NaN. + + Sample array, no sorting is assumed. + + + + Returns the order statistic (order 1..N) from the unsorted data array. + WARNING: Works inplace and can thus causes the data array to be reordered. + + Sample array, no sorting is assumed. Will be reordered. + One-based order of the statistic, must be between 1 and N (inclusive). + + + + Estimates the median value from the unsorted data array. + WARNING: Works inplace and can thus causes the data array to be reordered. + + Sample array, no sorting is assumed. Will be reordered. + + + + Estimates the p-Percentile value from the unsorted data array. + If a non-integer Percentile is needed, use Quantile instead. + Approximately median-unbiased regardless of the sample distribution (R8). + WARNING: Works inplace and can thus causes the data array to be reordered. + + Sample array, no sorting is assumed. Will be reordered. + Percentile selector, between 0 and 100 (inclusive). + + + + Estimates the first quartile value from the unsorted data array. + Approximately median-unbiased regardless of the sample distribution (R8). + WARNING: Works inplace and can thus causes the data array to be reordered. + + Sample array, no sorting is assumed. Will be reordered. + + + + Estimates the third quartile value from the unsorted data array. + Approximately median-unbiased regardless of the sample distribution (R8). + WARNING: Works inplace and can thus causes the data array to be reordered. + + Sample array, no sorting is assumed. Will be reordered. + + + + Estimates the inter-quartile range from the unsorted data array. + Approximately median-unbiased regardless of the sample distribution (R8). + WARNING: Works inplace and can thus causes the data array to be reordered. + + Sample array, no sorting is assumed. Will be reordered. + + + + Estimates {min, lower-quantile, median, upper-quantile, max} from the unsorted data array. + Approximately median-unbiased regardless of the sample distribution (R8). + WARNING: Works inplace and can thus causes the data array to be reordered. + + Sample array, no sorting is assumed. Will be reordered. + + + + Estimates the tau-th quantile from the unsorted data array. + The tau-th quantile is the data value where the cumulative distribution + function crosses tau. + Approximately median-unbiased regardless of the sample distribution (R8). + WARNING: Works inplace and can thus causes the data array to be reordered. + + Sample array, no sorting is assumed. Will be reordered. + Quantile selector, between 0.0 and 1.0 (inclusive). + + R-8, SciPy-(1/3,1/3): + Linear interpolation of the approximate medians for order statistics. + When tau < (2/3) / (N + 1/3), use x1. When tau >= (N - 1/3) / (N + 1/3), use xN. + + + + + Estimates the tau-th quantile from the unsorted data array. + The tau-th quantile is the data value where the cumulative distribution + function crosses tau. The quantile definition can be specified + by 4 parameters a, b, c and d, consistent with Mathematica. + WARNING: Works inplace and can thus causes the data array to be reordered. + + Sample array, no sorting is assumed. Will be reordered. + Quantile selector, between 0.0 and 1.0 (inclusive) + a-parameter + b-parameter + c-parameter + d-parameter + + + + Estimates the tau-th quantile from the unsorted data array. + The tau-th quantile is the data value where the cumulative distribution + function crosses tau. The quantile definition can be specified to be compatible + with an existing system. + WARNING: Works inplace and can thus causes the data array to be reordered. + + Sample array, no sorting is assumed. Will be reordered. + Quantile selector, between 0.0 and 1.0 (inclusive) + Quantile definition, to choose what product/definition it should be consistent with + + + + Evaluates the rank of each entry of the unsorted data array. + The rank definition can be specified to be compatible + with an existing system. + WARNING: Works inplace and can thus causes the data array to be reordered. + + + + + Estimates the arithmetic sample mean from the unsorted data array. + Returns NaN if data is empty or any entry is NaN. + + Sample array, no sorting is assumed. + + + + Evaluates the geometric mean of the unsorted data array. + Returns NaN if data is empty or any entry is NaN. + + Sample array, no sorting is assumed. + + + + Evaluates the harmonic mean of the unsorted data array. + Returns NaN if data is empty or any entry is NaN. + + Sample array, no sorting is assumed. + + + + Estimates the unbiased population variance from the provided samples as unsorted array. + On a dataset of size N will use an N-1 normalizer (Bessel's correction). + Returns NaN if data has less than two entries or if any entry is NaN. + + Sample array, no sorting is assumed. + + + + Evaluates the population variance from the full population provided as unsorted array. + On a dataset of size N will use an N normalizer and would thus be biased if applied to a subset. + Returns NaN if data is empty or if any entry is NaN. + + Sample array, no sorting is assumed. + + + + Estimates the unbiased population standard deviation from the provided samples as unsorted array. + On a dataset of size N will use an N-1 normalizer (Bessel's correction). + Returns NaN if data has less than two entries or if any entry is NaN. + + Sample array, no sorting is assumed. + + + + Evaluates the population standard deviation from the full population provided as unsorted array. + On a dataset of size N will use an N normalizer and would thus be biased if applied to a subset. + Returns NaN if data is empty or if any entry is NaN. + + Sample array, no sorting is assumed. + + + + Estimates the arithmetic sample mean and the unbiased population variance from the provided samples as unsorted array. + On a dataset of size N will use an N-1 normalizer (Bessel's correction). + Returns NaN for mean if data is empty or any entry is NaN and NaN for variance if data has less than two entries or if any entry is NaN. + + Sample array, no sorting is assumed. + + + + Estimates the arithmetic sample mean and the unbiased population standard deviation from the provided samples as unsorted array. + On a dataset of size N will use an N-1 normalizer (Bessel's correction). + Returns NaN for mean if data is empty or any entry is NaN and NaN for standard deviation if data has less than two entries or if any entry is NaN. + + Sample array, no sorting is assumed. + + + + Estimates the unbiased population covariance from the provided two sample arrays. + On a dataset of size N will use an N-1 normalizer (Bessel's correction). + Returns NaN if data has less than two entries or if any entry is NaN. + + First sample array. + Second sample array. + + + + Evaluates the population covariance from the full population provided as two arrays. + On a dataset of size N will use an N normalizer and would thus be biased if applied to a subset. + Returns NaN if data is empty or if any entry is NaN. + + First population array. + Second population array. + + + + Estimates the root mean square (RMS) also known as quadratic mean from the unsorted data array. + Returns NaN if data is empty or any entry is NaN. + + Sample array, no sorting is assumed. + + + + Returns the smallest value from the unsorted data array. + Returns NaN if data is empty or any entry is NaN. + + Sample array, no sorting is assumed. + + + + Returns the smallest value from the unsorted data array. + Returns NaN if data is empty or any entry is NaN. + + Sample array, no sorting is assumed. + + + + Returns the smallest absolute value from the unsorted data array. + Returns NaN if data is empty or any entry is NaN. + + Sample array, no sorting is assumed. + + + + Returns the largest absolute value from the unsorted data array. + Returns NaN if data is empty or any entry is NaN. + + Sample array, no sorting is assumed. + + + + Estimates the arithmetic sample mean from the unsorted data array. + Returns NaN if data is empty or any entry is NaN. + + Sample array, no sorting is assumed. + + + + Evaluates the geometric mean of the unsorted data array. + Returns NaN if data is empty or any entry is NaN. + + Sample array, no sorting is assumed. + + + + Evaluates the harmonic mean of the unsorted data array. + Returns NaN if data is empty or any entry is NaN. + + Sample array, no sorting is assumed. + + + + Estimates the unbiased population variance from the provided samples as unsorted array. + On a dataset of size N will use an N-1 normalizer (Bessel's correction). + Returns NaN if data has less than two entries or if any entry is NaN. + + Sample array, no sorting is assumed. + + + + Evaluates the population variance from the full population provided as unsorted array. + On a dataset of size N will use an N normalizer and would thus be biased if applied to a subset. + Returns NaN if data is empty or if any entry is NaN. + + Sample array, no sorting is assumed. + + + + Estimates the unbiased population standard deviation from the provided samples as unsorted array. + On a dataset of size N will use an N-1 normalizer (Bessel's correction). + Returns NaN if data has less than two entries or if any entry is NaN. + + Sample array, no sorting is assumed. + + + + Evaluates the population standard deviation from the full population provided as unsorted array. + On a dataset of size N will use an N normalizer and would thus be biased if applied to a subset. + Returns NaN if data is empty or if any entry is NaN. + + Sample array, no sorting is assumed. + + + + Estimates the arithmetic sample mean and the unbiased population variance from the provided samples as unsorted array. + On a dataset of size N will use an N-1 normalizer (Bessel's correction). + Returns NaN for mean if data is empty or any entry is NaN and NaN for variance if data has less than two entries or if any entry is NaN. + + Sample array, no sorting is assumed. + + + + Estimates the arithmetic sample mean and the unbiased population standard deviation from the provided samples as unsorted array. + On a dataset of size N will use an N-1 normalizer (Bessel's correction). + Returns NaN for mean if data is empty or any entry is NaN and NaN for standard deviation if data has less than two entries or if any entry is NaN. + + Sample array, no sorting is assumed. + + + + Estimates the unbiased population covariance from the provided two sample arrays. + On a dataset of size N will use an N-1 normalizer (Bessel's correction). + Returns NaN if data has less than two entries or if any entry is NaN. + + First sample array. + Second sample array. + + + + Evaluates the population covariance from the full population provided as two arrays. + On a dataset of size N will use an N normalizer and would thus be biased if applied to a subset. + Returns NaN if data is empty or if any entry is NaN. + + First population array. + Second population array. + + + + Estimates the root mean square (RMS) also known as quadratic mean from the unsorted data array. + Returns NaN if data is empty or any entry is NaN. + + Sample array, no sorting is assumed. + + + + Returns the order statistic (order 1..N) from the unsorted data array. + WARNING: Works inplace and can thus causes the data array to be reordered. + + Sample array, no sorting is assumed. Will be reordered. + One-based order of the statistic, must be between 1 and N (inclusive). + + + + Estimates the median value from the unsorted data array. + WARNING: Works inplace and can thus causes the data array to be reordered. + + Sample array, no sorting is assumed. Will be reordered. + + + + Estimates the p-Percentile value from the unsorted data array. + If a non-integer Percentile is needed, use Quantile instead. + Approximately median-unbiased regardless of the sample distribution (R8). + WARNING: Works inplace and can thus causes the data array to be reordered. + + Sample array, no sorting is assumed. Will be reordered. + Percentile selector, between 0 and 100 (inclusive). + + + + Estimates the first quartile value from the unsorted data array. + Approximately median-unbiased regardless of the sample distribution (R8). + WARNING: Works inplace and can thus causes the data array to be reordered. + + Sample array, no sorting is assumed. Will be reordered. + + + + Estimates the third quartile value from the unsorted data array. + Approximately median-unbiased regardless of the sample distribution (R8). + WARNING: Works inplace and can thus causes the data array to be reordered. + + Sample array, no sorting is assumed. Will be reordered. + + + + Estimates the inter-quartile range from the unsorted data array. + Approximately median-unbiased regardless of the sample distribution (R8). + WARNING: Works inplace and can thus causes the data array to be reordered. + + Sample array, no sorting is assumed. Will be reordered. + + + + Estimates {min, lower-quantile, median, upper-quantile, max} from the unsorted data array. + Approximately median-unbiased regardless of the sample distribution (R8). + WARNING: Works inplace and can thus causes the data array to be reordered. + + Sample array, no sorting is assumed. Will be reordered. + + + + Estimates the tau-th quantile from the unsorted data array. + The tau-th quantile is the data value where the cumulative distribution + function crosses tau. + Approximately median-unbiased regardless of the sample distribution (R8). + WARNING: Works inplace and can thus causes the data array to be reordered. + + Sample array, no sorting is assumed. Will be reordered. + Quantile selector, between 0.0 and 1.0 (inclusive). + + R-8, SciPy-(1/3,1/3): + Linear interpolation of the approximate medians for order statistics. + When tau < (2/3) / (N + 1/3), use x1. When tau >= (N - 1/3) / (N + 1/3), use xN. + + + + + Estimates the tau-th quantile from the unsorted data array. + The tau-th quantile is the data value where the cumulative distribution + function crosses tau. The quantile definition can be specified + by 4 parameters a, b, c and d, consistent with Mathematica. + WARNING: Works inplace and can thus causes the data array to be reordered. + + Sample array, no sorting is assumed. Will be reordered. + Quantile selector, between 0.0 and 1.0 (inclusive) + a-parameter + b-parameter + c-parameter + d-parameter + + + + Estimates the tau-th quantile from the unsorted data array. + The tau-th quantile is the data value where the cumulative distribution + function crosses tau. The quantile definition can be specified to be compatible + with an existing system. + WARNING: Works inplace and can thus causes the data array to be reordered. + + Sample array, no sorting is assumed. Will be reordered. + Quantile selector, between 0.0 and 1.0 (inclusive) + Quantile definition, to choose what product/definition it should be consistent with + + + + Evaluates the rank of each entry of the unsorted data array. + The rank definition can be specified to be compatible + with an existing system. + WARNING: Works inplace and can thus causes the data array to be reordered. + + + + + A class with correlation measures between two datasets. + + + + + Auto-correlation function (ACF) based on FFT for all possible lags k. + + Data array to calculate auto correlation for. + An array with the ACF as a function of the lags k. + + + + Auto-correlation function (ACF) based on FFT for lags between kMin and kMax. + + The data array to calculate auto correlation for. + Max lag to calculate ACF for must be positive and smaller than x.Length. + Min lag to calculate ACF for (0 = no shift with acf=1) must be zero or positive and smaller than x.Length. + An array with the ACF as a function of the lags k. + + + + Auto-correlation function based on FFT for lags k. + + The data array to calculate auto correlation for. + Array with lags to calculate ACF for. + An array with the ACF as a function of the lags k. + + + + The internal method for calculating the auto-correlation. + + The data array to calculate auto-correlation for + Min lag to calculate ACF for (0 = no shift with acf=1) must be zero or positive and smaller than x.Length + Max lag (EXCLUSIVE) to calculate ACF for must be positive and smaller than x.Length + An array with the ACF as a function of the lags k. + + + + Computes the Pearson Product-Moment Correlation coefficient. + + Sample data A. + Sample data B. + The Pearson product-moment correlation coefficient. + + + + Computes the Weighted Pearson Product-Moment Correlation coefficient. + + Sample data A. + Sample data B. + Corresponding weights of data. + The Weighted Pearson product-moment correlation coefficient. + + + + Computes the Pearson Product-Moment Correlation matrix. + + Array of sample data vectors. + The Pearson product-moment correlation matrix. + + + + Computes the Pearson Product-Moment Correlation matrix. + + Enumerable of sample data vectors. + The Pearson product-moment correlation matrix. + + + + Computes the Spearman Ranked Correlation coefficient. + + Sample data series A. + Sample data series B. + The Spearman ranked correlation coefficient. + + + + Computes the Spearman Ranked Correlation matrix. + + Array of sample data vectors. + The Spearman ranked correlation matrix. + + + + Computes the Spearman Ranked Correlation matrix. + + Enumerable of sample data vectors. + The Spearman ranked correlation matrix. + + + + Computes the basic statistics of data set. The class meets the + NIST standard of accuracy for mean, variance, and standard deviation + (the only statistics they provide exact values for) and exceeds them + in increased accuracy mode. + Recommendation: consider to use RunningStatistics instead. + + + This type declares a DataContract for out of the box ephemeral serialization + with engines like DataContractSerializer, Protocol Buffers and FsPickler, + but does not guarantee any compatibility between versions. + It is not recommended to rely on this mechanism for durable persistence. + + + + + Initializes a new instance of the class. + + The sample data. + + If set to true, increased accuracy mode used. + Increased accuracy mode uses types for internal calculations. + + + Don't use increased accuracy for data sets containing large values (in absolute value). + This may cause the calculations to overflow. + + + + + Initializes a new instance of the class. + + The sample data. + + If set to true, increased accuracy mode used. + Increased accuracy mode uses types for internal calculations. + + + Don't use increased accuracy for data sets containing large values (in absolute value). + This may cause the calculations to overflow. + + + + + Gets the size of the sample. + + The size of the sample. + + + + Gets the sample mean. + + The sample mean. + + + + Gets the unbiased population variance estimator (on a dataset of size N will use an N-1 normalizer). + + The sample variance. + + + + Gets the unbiased population standard deviation (on a dataset of size N will use an N-1 normalizer). + + The sample standard deviation. + + + + Gets the sample skewness. + + The sample skewness. + Returns zero if is less than three. + + + + Gets the sample kurtosis. + + The sample kurtosis. + Returns zero if is less than four. + + + + Gets the maximum sample value. + + The maximum sample value. + + + + Gets the minimum sample value. + + The minimum sample value. + + + + Computes descriptive statistics from a stream of data values. + + A sequence of datapoints. + + + + Computes descriptive statistics from a stream of nullable data values. + + A sequence of datapoints. + + + + Computes descriptive statistics from a stream of data values. + + A sequence of datapoints. + + + + Computes descriptive statistics from a stream of nullable data values. + + A sequence of datapoints. + + + + Internal use. Method use for setting the statistics. + + For setting Mean. + For setting Variance. + For setting Skewness. + For setting Kurtosis. + For setting Minimum. + For setting Maximum. + For setting Count. + + + + A consists of a series of s, + each representing a region limited by a lower bound (exclusive) and an upper bound (inclusive). + + + This type declares a DataContract for out of the box ephemeral serialization + with engines like DataContractSerializer, Protocol Buffers and FsPickler, + but does not guarantee any compatibility between versions. + It is not recommended to rely on this mechanism for durable persistence. + + + + + This IComparer performs comparisons between a point and a bucket. + + + + + Compares a point and a bucket. The point will be encapsulated in a bucket with width 0. + + The first bucket to compare. + The second bucket to compare. + -1 when the point is less than this bucket, 0 when it is in this bucket and 1 otherwise. + + + + Lower Bound of the Bucket. + + + + + Upper Bound of the Bucket. + + + + + The number of datapoints in the bucket. + + + Value may be NaN if this was constructed as a argument. + + + + + Initializes a new instance of the Bucket class. + + + + + Constructs a Bucket that can be used as an argument for a + like when performing a Binary search. + + Value to look for + + + + Creates a copy of the Bucket with the lowerbound, upperbound and counts exactly equal. + + A cloned Bucket object. + + + + Width of the Bucket. + + + + + True if this is a single point argument for + when performing a Binary search. + + + + + Default comparer. + + + + + This method check whether a point is contained within this bucket. + + The point to check. + + 0 if the point falls within the bucket boundaries; + -1 if the point is smaller than the bucket, + +1 if the point is larger than the bucket. + + + + Comparison of two disjoint buckets. The buckets cannot be overlapping. + + + 0 if UpperBound and LowerBound are bit-for-bit equal + 1 if This bucket is lower that the compared bucket + -1 otherwise + + + + + Checks whether two Buckets are equal. + + + UpperBound and LowerBound are compared bit-for-bit, but This method tolerates a + difference in Count given by . + + + + + Provides a hash code for this bucket. + + + + + Formats a human-readable string for this bucket. + + + + + A class which computes histograms of data. + + + + + Contains all the Buckets of the Histogram. + + + + + Indicates whether the elements of buckets are currently sorted. + + + + + Initializes a new instance of the Histogram class. + + + + + Constructs a Histogram with a specific number of equally sized buckets. The upper and lower bound of the histogram + will be set to the smallest and largest datapoint. + + The data sequence to build a histogram on. + The number of buckets to use. + + + + Constructs a Histogram with a specific number of equally sized buckets. + + The data sequence to build a histogram on. + The number of buckets to use. + The histogram lower bound. + The histogram upper bound. + + + + Add one data point to the histogram. If the datapoint falls outside the range of the histogram, + the lowerbound or upperbound will automatically adapt. + + The datapoint which we want to add. + + + + Add a sequence of data point to the histogram. If the datapoint falls outside the range of the histogram, + the lowerbound or upperbound will automatically adapt. + + The sequence of datapoints which we want to add. + + + + Adds a Bucket to the Histogram. + + + + + Sort the buckets if needed. + + + + + Returns the Bucket that contains the value v. + + The point to search the bucket for. + A copy of the bucket containing point . + + + + Returns the index in the Histogram of the Bucket + that contains the value v. + + The point to search the bucket index for. + The index of the bucket containing the point. + + + + Returns the lower bound of the histogram. + + + + + Returns the upper bound of the histogram. + + + + + Gets the n'th bucket. + + The index of the bucket to be returned. + A copy of the n'th bucket. + + + + Gets the number of buckets. + + + + + Gets the total number of datapoints in the histogram. + + + + + Prints the buckets contained in the . + + + + + Kernel density estimation (KDE). + + + + + Estimate the probability density function of a random variable. + + + The routine assumes that the provided kernel is well defined, i.e. a real non-negative function that integrates to 1. + + + + + Estimate the probability density function of a random variable with a Gaussian kernel. + + + + + Estimate the probability density function of a random variable with an Epanechnikov kernel. + The Epanechnikov kernel is optimal in a mean square error sense. + + + + + Estimate the probability density function of a random variable with a uniform kernel. + + + + + Estimate the probability density function of a random variable with a triangular kernel. + + + + + A Gaussian kernel (PDF of Normal distribution with mean 0 and variance 1). + This kernel is the default. + + + + + Epanechnikov Kernel: + x => Math.Abs(x) <= 1.0 ? 3.0/4.0(1.0-x^2) : 0.0 + + + + + Uniform Kernel: + x => Math.Abs(x) <= 1.0 ? 1.0/2.0 : 0.0 + + + + + Triangular Kernel: + x => Math.Abs(x) <= 1.0 ? (1.0-Math.Abs(x)) : 0.0 + + + + + A hybrid Monte Carlo sampler for multivariate distributions. + + + + + Number of parameters in the density function. + + + + + Distribution to sample momentum from. + + + + + Standard deviations used in the sampling of different components of the + momentum. + + + + + Gets or sets the standard deviations used in the sampling of different components of the + momentum. + + When the length of pSdv is not the same as Length. + + + + Constructs a new Hybrid Monte Carlo sampler for a multivariate probability distribution. + The components of the momentum will be sampled from a normal distribution with standard deviation + 1 using the default random + number generator. A three point estimation will be used for differentiation. + This constructor will set the burn interval. + + The initial sample. + The log density of the distribution we want to sample from. + Number frog leap simulation steps. + Size of the frog leap simulation steps. + The number of iterations in between returning samples. + When the number of burnInterval iteration is negative. + + + + Constructs a new Hybrid Monte Carlo sampler for a multivariate probability distribution. + The components of the momentum will be sampled from a normal distribution with standard deviation + specified by pSdv using the default random + number generator. A three point estimation will be used for differentiation. + This constructor will set the burn interval. + + The initial sample. + The log density of the distribution we want to sample from. + Number frog leap simulation steps. + Size of the frog leap simulation steps. + The number of iterations in between returning samples. + The standard deviations of the normal distributions that are used to sample + the components of the momentum. + When the number of burnInterval iteration is negative. + + + + Constructs a new Hybrid Monte Carlo sampler for a multivariate probability distribution. + The components of the momentum will be sampled from a normal distribution with standard deviation + specified by pSdv using the a random number generator provided by the user. + A three point estimation will be used for differentiation. + This constructor will set the burn interval. + + The initial sample. + The log density of the distribution we want to sample from. + Number frog leap simulation steps. + Size of the frog leap simulation steps. + The number of iterations in between returning samples. + The standard deviations of the normal distributions that are used to sample + the components of the momentum. + Random number generator used for sampling the momentum. + When the number of burnInterval iteration is negative. + + + + Constructs a new Hybrid Monte Carlo sampler for a multivariate probability distribution. + The components of the momentum will be sampled from a normal distribution with standard deviations + given by pSdv. This constructor will set the burn interval, the method used for + numerical differentiation and the random number generator. + + The initial sample. + The log density of the distribution we want to sample from. + Number frog leap simulation steps. + Size of the frog leap simulation steps. + The number of iterations in between returning samples. + The standard deviations of the normal distributions that are used to sample + the components of the momentum. + Random number generator used for sampling the momentum. + The method used for numerical differentiation. + When the number of burnInterval iteration is negative. + When the length of pSdv is not the same as x0. + + + + Initialize parameters. + + The current location of the sampler. + + + + Checking that the location and the momentum are of the same dimension and that each component is positive. + + The standard deviations used for sampling the momentum. + When the length of pSdv is not the same as Length or if any + component is negative. + When pSdv is null. + + + + Use for copying objects in the Burn method. + + The source of copying. + A copy of the source object. + + + + Use for creating temporary objects in the Burn method. + + An object of type T. + + + + + + + + + + + + + Samples the momentum from a normal distribution. + + The momentum to be randomized. + + + + The default method used for computing the gradient. Uses a simple three point estimation. + + Function which the gradient is to be evaluated. + The location where the gradient is to be evaluated. + The gradient of the function at the point x. + + + + The Hybrid (also called Hamiltonian) Monte Carlo produces samples from distribution P using a set + of Hamiltonian equations to guide the sampling process. It uses the negative of the log density as + a potential energy, and a randomly generated momentum to set up a Hamiltonian system, which is then used + to sample the distribution. This can result in a faster convergence than the random walk Metropolis sampler + (). + + The type of samples this sampler produces. + + + + The delegate type that defines a derivative evaluated at a certain point. + + Function to be differentiated. + Value where the derivative is computed. + + + + Evaluates the energy function of the target distribution. + + + + + The current location of the sampler. + + + + + The number of burn iterations between two samples. + + + + + The size of each step in the Hamiltonian equation. + + + + + The number of iterations in the Hamiltonian equation. + + + + + The algorithm used for differentiation. + + + + + Gets or sets the number of iterations in between returning samples. + + When burn interval is negative. + + + + Gets or sets the number of iterations in the Hamiltonian equation. + + When frog leap steps is negative or zero. + + + + Gets or sets the size of each step in the Hamiltonian equation. + + When step size is negative or zero. + + + + Constructs a new Hybrid Monte Carlo sampler. + + The initial sample. + The log density of the distribution we want to sample from. + Number frog leap simulation steps. + Size of the frog leap simulation steps. + The number of iterations in between returning samples. + Random number generator used for sampling the momentum. + The method used for differentiation. + When the number of burnInterval iteration is negative. + When either x0, pdfLnP or diff is null. + + + + Returns a sample from the distribution P. + + + + + This method runs the sampler for a number of iterations without returning a sample + + + + + Method used to update the sample location. Used in the end of the loop. + + The old energy. + The old gradient/derivative of the energy. + The new sample. + The new gradient/derivative of the energy. + The new energy. + The difference between the old Hamiltonian and new Hamiltonian. Use to determine + if an update should take place. + + + + Use for creating temporary objects in the Burn method. + + An object of type T. + + + + Use for copying objects in the Burn method. + + The source of copying. + A copy of the source object. + + + + Method for doing dot product. + + First vector/scalar in the product. + Second vector/scalar in the product. + + + + Method for adding, multiply the second vector/scalar by factor and then + add it to the first vector/scalar. + + First vector/scalar. + Scalar factor multiplying by the second vector/scalar. + Second vector/scalar. + + + + Multiplying the second vector/scalar by factor and then subtract it from + the first vector/scalar. + + First vector/scalar. + Scalar factor to be multiplied to the second vector/scalar. + Second vector/scalar. + + + + Method for sampling a random momentum. + + Momentum to be randomized. + + + + The Hamiltonian equations that is used to produce the new sample. + + + + + Method to compute the Hamiltonian used in the method. + + The momentum. + The energy. + Hamiltonian=E+p.p/2 + + + + Method to check and set a quantity to a non-negative value. + + Proposed value to be checked. + Returns value if it is greater than or equal to zero. + Throws when value is negative. + + + + Method to check and set a quantity to a non-negative value. + + Proposed value to be checked. + Returns value if it is greater than to zero. + Throws when value is negative or zero. + + + + Method to check and set a quantity to a non-negative value. + + Proposed value to be checked. + Returns value if it is greater than zero. + Throws when value is negative or zero. + + + + Provides utilities to analysis the convergence of a set of samples from + a . + + + + + Computes the auto correlations of a series evaluated by a function f. + + The series for computing the auto correlation. + The lag in the series + The function used to evaluate the series. + The auto correlation. + Throws if lag is zero or if lag is + greater than or equal to the length of Series. + + + + Computes the effective size of the sample when evaluated by a function f. + + The samples. + The function use for evaluating the series. + The effective size when auto correlation is taken into account. + + + + A method which samples datapoints from a proposal distribution. The implementation of this sampler + is stateless: no variables are saved between two calls to Sample. This proposal is different from + in that it doesn't take any parameters; it samples random + variables from the whole domain. + + The type of the datapoints. + A sample from the proposal distribution. + + + + A method which samples datapoints from a proposal distribution given an initial sample. The implementation + of this sampler is stateless: no variables are saved between two calls to Sample. This proposal is different from + in that it samples locally around an initial point. In other words, it + makes a small local move rather than producing a global sample from the proposal. + + The type of the datapoints. + The initial sample. + A sample from the proposal distribution. + + + + A function which evaluates a density. + + The type of data the distribution is over. + The sample we want to evaluate the density for. + + + + A function which evaluates a log density. + + The type of data the distribution is over. + The sample we want to evaluate the log density for. + + + + A function which evaluates the log of a transition kernel probability. + + The type for the space over which this transition kernel is defined. + The new state in the transition. + The previous state in the transition. + The log probability of the transition. + + + + The interface which every sampler must implement. + + The type of samples this sampler produces. + + + + The random number generator for this class. + + + + + Keeps track of the number of accepted samples. + + + + + Keeps track of the number of calls to the proposal sampler. + + + + + Initializes a new instance of the class. + + Thread safe instances are two and half times slower than non-thread + safe classes. + + + + Gets or sets the random number generator. + + When the random number generator is null. + + + + Returns one sample. + + + + + Returns a number of samples. + + The number of samples we want. + An array of samples. + + + + Gets the acceptance rate of the sampler. + + + + + Metropolis-Hastings sampling produces samples from distribution P by sampling from a proposal distribution Q + and accepting/rejecting based on the density of P. Metropolis-Hastings sampling doesn't require that the + proposal distribution Q is symmetric in comparison to . It does need to + be able to evaluate the proposal sampler's log density though. All densities are required to be in log space. + + The Metropolis-Hastings sampler is a stateful sampler. It keeps track of where it currently is in the domain + of the distribution P. + + The type of samples this sampler produces. + + + + Evaluates the log density function of the target distribution. + + + + + Evaluates the log transition probability for the proposal distribution. + + + + + A function which samples from a proposal distribution. + + + + + The current location of the sampler. + + + + + The log density at the current location. + + + + + The number of burn iterations between two samples. + + + + + Constructs a new Metropolis-Hastings sampler using the default random number generator. This + constructor will set the burn interval. + + The initial sample. + The log density of the distribution we want to sample from. + The log transition probability for the proposal distribution. + A method that samples from the proposal distribution. + The number of iterations in between returning samples. + When the number of burnInterval iteration is negative. + + + + Gets or sets the number of iterations in between returning samples. + + When burn interval is negative. + + + + This method runs the sampler for a number of iterations without returning a sample + + + + + Returns a sample from the distribution P. + + + + + Metropolis sampling produces samples from distribution P by sampling from a proposal distribution Q + and accepting/rejecting based on the density of P. Metropolis sampling requires that the proposal + distribution Q is symmetric. All densities are required to be in log space. + + The Metropolis sampler is a stateful sampler. It keeps track of where it currently is in the domain + of the distribution P. + + The type of samples this sampler produces. + + + + Evaluates the log density function of the sampling distribution. + + + + + A function which samples from a proposal distribution. + + + + + The current location of the sampler. + + + + + The log density at the current location. + + + + + The number of burn iterations between two samples. + + + + + Constructs a new Metropolis sampler using the default random number generator. + + The initial sample. + The log density of the distribution we want to sample from. + A method that samples from the symmetric proposal distribution. + The number of iterations in between returning samples. + When the number of burnInterval iteration is negative. + + + + Gets or sets the number of iterations in between returning samples. + + When burn interval is negative. + + + + This method runs the sampler for a number of iterations without returning a sample + + + + + Returns a sample from the distribution P. + + + + + Rejection sampling produces samples from distribution P by sampling from a proposal distribution Q + and accepting/rejecting based on the density of P and Q. The density of P and Q don't need to + to be normalized, but we do need that for each x, P(x) < Q(x). + + The type of samples this sampler produces. + + + + Evaluates the density function of the sampling distribution. + + + + + Evaluates the density function of the proposal distribution. + + + + + A function which samples from a proposal distribution. + + + + + Constructs a new rejection sampler using the default random number generator. + + The density of the distribution we want to sample from. + The density of the proposal distribution. + A method that samples from the proposal distribution. + + + + Returns a sample from the distribution P. + + When the algorithms detects that the proposal + distribution doesn't upper bound the target distribution. + + + + A hybrid Monte Carlo sampler for univariate distributions. + + + + + Distribution to sample momentum from. + + + + + Standard deviations used in the sampling of the + momentum. + + + + + Gets or sets the standard deviation used in the sampling of the + momentum. + + When standard deviation is negative. + + + + Constructs a new Hybrid Monte Carlo sampler for a univariate probability distribution. + The momentum will be sampled from a normal distribution with standard deviation + specified by pSdv using the default random + number generator. A three point estimation will be used for differentiation. + This constructor will set the burn interval. + + The initial sample. + The log density of the distribution we want to sample from. + Number frog leap simulation steps. + Size of the frog leap simulation steps. + The number of iterations in between returning samples. + The standard deviation of the normal distribution that is used to sample + the momentum. + When the number of burnInterval iteration is negative. + + + + Constructs a new Hybrid Monte Carlo sampler for a univariate probability distribution. + The momentum will be sampled from a normal distribution with standard deviation + specified by pSdv using a random + number generator provided by the user. A three point estimation will be used for differentiation. + This constructor will set the burn interval. + + The initial sample. + The log density of the distribution we want to sample from. + Number frog leap simulation steps. + Size of the frog leap simulation steps. + The number of iterations in between returning samples. + The standard deviation of the normal distribution that is used to sample + the momentum. + Random number generator used to sample the momentum. + When the number of burnInterval iteration is negative. + + + + Constructs a new Hybrid Monte Carlo sampler for a multivariate probability distribution. + The momentum will be sampled from a normal distribution with standard deviation + given by pSdv using a random + number generator provided by the user. This constructor will set both the burn interval and the method used for + numerical differentiation. + + The initial sample. + The log density of the distribution we want to sample from. + Number frog leap simulation steps. + Size of the frog leap simulation steps. + The number of iterations in between returning samples. + The standard deviation of the normal distribution that is used to sample + the momentum. + The method used for numerical differentiation. + Random number generator used for sampling the momentum. + When the number of burnInterval iteration is negative. + + + + Use for copying objects in the Burn method. + + The source of copying. + A copy of the source object. + + + + Use for creating temporary objects in the Burn method. + + An object of type T. + + + + + + + + + + + + + Samples the momentum from a normal distribution. + + The momentum to be randomized. + + + + The default method used for computing the derivative. Uses a simple three point estimation. + + Function for which the derivative is to be evaluated. + The location where the derivative is to be evaluated. + The derivative of the function at the point x. + + + + Slice sampling produces samples from distribution P by uniformly sampling from under the pdf of P using + a technique described in "Slice Sampling", R. Neal, 2003. All densities are required to be in log space. + + The slice sampler is a stateful sampler. It keeps track of where it currently is in the domain + of the distribution P. + + + + + Evaluates the log density function of the target distribution. + + + + + The current location of the sampler. + + + + + The log density at the current location. + + + + + The number of burn iterations between two samples. + + + + + The scale of the slice sampler. + + + + + Constructs a new Slice sampler using the default random + number generator. The burn interval will be set to 0. + + The initial sample. + The density of the distribution we want to sample from. + The scale factor of the slice sampler. + When the scale of the slice sampler is not positive. + + + + Constructs a new slice sampler using the default random number generator. It + will set the number of burnInterval iterations and run a burnInterval phase. + + The initial sample. + The density of the distribution we want to sample from. + The number of iterations in between returning samples. + The scale factor of the slice sampler. + When the number of burnInterval iteration is negative. + When the scale of the slice sampler is not positive. + + + + Gets or sets the number of iterations in between returning samples. + + When burn interval is negative. + + + + Gets or sets the scale of the slice sampler. + + + + + This method runs the sampler for a number of iterations without returning a sample + + + + + Returns a sample from the distribution P. + + + + + Running statistics over a window of data, allows updating by adding values. + + + + + Gets the total number of samples. + + + + + Returns the minimum value in the sample data. + Returns NaN if data is empty or if any entry is NaN. + + + + + Returns the maximum value in the sample data. + Returns NaN if data is empty or if any entry is NaN. + + + + + Evaluates the sample mean, an estimate of the population mean. + Returns NaN if data is empty or if any entry is NaN. + + + + + Estimates the unbiased population variance from the provided samples. + On a dataset of size N will use an N-1 normalizer (Bessel's correction). + Returns NaN if data has less than two entries or if any entry is NaN. + + + + + Evaluates the variance from the provided full population. + On a dataset of size N will use an N normalizer and would thus be biased if applied to a subset. + Returns NaN if data is empty or if any entry is NaN. + + + + + Estimates the unbiased population standard deviation from the provided samples. + On a dataset of size N will use an N-1 normalizer (Bessel's correction). + Returns NaN if data has less than two entries or if any entry is NaN. + + + + + Evaluates the standard deviation from the provided full population. + On a dataset of size N will use an N normalizer and would thus be biased if applied to a subset. + Returns NaN if data is empty or if any entry is NaN. + + + + + Update the running statistics by adding another observed sample (in-place). + + + + + Update the running statistics by adding a sequence of observed sample (in-place). + + + + Replace ties with their mean (non-integer ranks). Default. + + + Replace ties with their minimum (typical sports ranking). + + + Replace ties with their maximum. + + + Permutation with increasing values at each index of ties. + + + + Running statistics accumulator, allows updating by adding values + or by combining two accumulators. + + + This type declares a DataContract for out of the box ephemeral serialization + with engines like DataContractSerializer, Protocol Buffers and FsPickler, + but does not guarantee any compatibility between versions. + It is not recommended to rely on this mechanism for durable persistence. + + + + + Gets the total number of samples. + + + + + Returns the minimum value in the sample data. + Returns NaN if data is empty or if any entry is NaN. + + + + + Returns the maximum value in the sample data. + Returns NaN if data is empty or if any entry is NaN. + + + + + Evaluates the sample mean, an estimate of the population mean. + Returns NaN if data is empty or if any entry is NaN. + + + + + Estimates the unbiased population variance from the provided samples. + On a dataset of size N will use an N-1 normalizer (Bessel's correction). + Returns NaN if data has less than two entries or if any entry is NaN. + + + + + Evaluates the variance from the provided full population. + On a dataset of size N will use an N normalizer and would thus be biased if applied to a subset. + Returns NaN if data is empty or if any entry is NaN. + + + + + Estimates the unbiased population standard deviation from the provided samples. + On a dataset of size N will use an N-1 normalizer (Bessel's correction). + Returns NaN if data has less than two entries or if any entry is NaN. + + + + + Evaluates the standard deviation from the provided full population. + On a dataset of size N will use an N normalizer and would thus be biased if applied to a subset. + Returns NaN if data is empty or if any entry is NaN. + + + + + Estimates the unbiased population skewness from the provided samples. + Uses a normalizer (Bessel's correction; type 2). + Returns NaN if data has less than three entries or if any entry is NaN. + + + + + Evaluates the population skewness from the full population. + Does not use a normalizer and would thus be biased if applied to a subset (type 1). + Returns NaN if data has less than two entries or if any entry is NaN. + + + + + Estimates the unbiased population excess kurtosis from the provided samples. + Uses a normalizer (Bessel's correction; type 2). + Returns NaN if data has less than four entries or if any entry is NaN. + + + + + Evaluates the population excess kurtosis from the full population. + Does not use a normalizer and would thus be biased if applied to a subset (type 1). + Returns NaN if data has less than three entries or if any entry is NaN. + + + + + Update the running statistics by adding another observed sample (in-place). + + + + + Update the running statistics by adding a sequence of observed sample (in-place). + + + + + Create a new running statistics over the combined samples of two existing running statistics. + + + + + Running weighted statistics accumulator, allows updating by adding values + or by combining two accumulators. Weights are reliability weights, not frequency weights. + + + This type declares a DataContract for out of the box ephemeral serialization + with engines like DataContractSerializer, Protocol Buffers and FsPickler, + but does not guarantee any compatibility between versions. + It is not recommended to rely on this mechanism for durable persistence. + + + + + Second moment + + + + + Third moment + + + + + Fourth moment + + + + + Total weight + + + + + Total of weights to the second power + + + + + Total of weights to the third power + + + + + Total of weights to the fourth power + + + + + The denominator in the variance calculation to perform a Bessel correction. + + + + + Gets the total number of samples with non-zero weight. + + + + + Returns the minimum value in the sample data. + Returns NaN if data is empty or if any entry is NaN. + + + + + Returns the maximum value in the sample data. + Returns NaN if data is empty or if any entry is NaN. + + + + + Evaluates the sample mean, an estimate of the population mean. + Returns NaN if data is empty or if any entry is NaN. + + + + + Estimates the unbiased population variance from the provided samples. + Will use the Bessel correction for reliability weighting. + Returns NaN if data has less than two entries or if any entry is NaN. + + + + + Evaluates the variance from the provided full population. + On a dataset of size N will use an N normalizer and would thus be biased if applied to a subset. + Returns NaN if data is empty or if any entry is NaN. + + + + + Estimates the unbiased population standard deviation from the provided samples. + Will use the Bessel correction for reliability weighting. + Returns NaN if data has less than two entries or if any entry is NaN. + + + + + Evaluates the standard deviation from the provided full population. + On a dataset of size N will use an N normalizer and would thus be biased if applied to a subset. + Returns NaN if data is empty or if any entry is NaN. + + + + + Estimates the unbiased population skewness from the provided samples. + Will use the Bessel correction for reliability weighting. + Returns NaN if data has less than three entries or if any entry is NaN. + + + + + Evaluates the population skewness from the full population. + Does not use a normalizer and would thus be biased if applied to a subset (type 1). + Returns NaN if data has less than two entries or if any entry is NaN. + + + + + Estimates the unbiased population excess kurtosis from the provided samples. + Will use the Bessel correction for reliability weighting. + Returns NaN if data has less than four entries or if any entry is NaN. + Equivalent formula for this for weighted distributions are unknown. + + + + + Evaluates the population excess kurtosis from the full population. + Does not use a normalizer and would thus be biased if applied to a subset (type 1). + Returns NaN if data has less than three entries or if any entry is NaN. + + + + + Evaluates the total weight of the population. + + + + + The Kish's Effective Sample Size + + + + + Update the running statistics by adding another observed sample (in-place). + + + + + Update the running statistics by adding a sequence of weighted observatopms (in-place). + + + + + Update the running statistics by adding a sequence of weighted observatopms (in-place). + + + + + Create a new running statistics over the combined samples of two existing running statistics. + + + + + Statistics operating on an array already sorted ascendingly. + + + + + + + + Returns the smallest value from the sorted data array (ascending). + + Sample array, must be sorted ascendingly. + + + + Returns the largest value from the sorted data array (ascending). + + Sample array, must be sorted ascendingly. + + + + Returns the order statistic (order 1..N) from the sorted data array (ascending). + + Sample array, must be sorted ascendingly. + One-based order of the statistic, must be between 1 and N (inclusive). + + + + Estimates the median value from the sorted data array (ascending). + Approximately median-unbiased regardless of the sample distribution (R8). + + Sample array, must be sorted ascendingly. + + + + Estimates the p-Percentile value from the sorted data array (ascending). + If a non-integer Percentile is needed, use Quantile instead. + Approximately median-unbiased regardless of the sample distribution (R8). + + Sample array, must be sorted ascendingly. + Percentile selector, between 0 and 100 (inclusive). + + + + Estimates the first quartile value from the sorted data array (ascending). + Approximately median-unbiased regardless of the sample distribution (R8). + + Sample array, must be sorted ascendingly. + + + + Estimates the third quartile value from the sorted data array (ascending). + Approximately median-unbiased regardless of the sample distribution (R8). + + Sample array, must be sorted ascendingly. + + + + Estimates the inter-quartile range from the sorted data array (ascending). + Approximately median-unbiased regardless of the sample distribution (R8). + + Sample array, must be sorted ascendingly. + + + + Estimates {min, lower-quantile, median, upper-quantile, max} from the sorted data array (ascending). + Approximately median-unbiased regardless of the sample distribution (R8). + + Sample array, must be sorted ascendingly. + + + + Estimates the tau-th quantile from the sorted data array (ascending). + The tau-th quantile is the data value where the cumulative distribution + function crosses tau. + Approximately median-unbiased regardless of the sample distribution (R8). + + Sample array, must be sorted ascendingly. + Quantile selector, between 0.0 and 1.0 (inclusive). + + R-8, SciPy-(1/3,1/3): + Linear interpolation of the approximate medians for order statistics. + When tau < (2/3) / (N + 1/3), use x1. When tau >= (N - 1/3) / (N + 1/3), use xN. + + + + + Estimates the tau-th quantile from the sorted data array (ascending). + The tau-th quantile is the data value where the cumulative distribution + function crosses tau. The quantile definition can be specified + by 4 parameters a, b, c and d, consistent with Mathematica. + + Sample array, must be sorted ascendingly. + Quantile selector, between 0.0 and 1.0 (inclusive). + a-parameter + b-parameter + c-parameter + d-parameter + + + + Estimates the tau-th quantile from the sorted data array (ascending). + The tau-th quantile is the data value where the cumulative distribution + function crosses tau. The quantile definition can be specified to be compatible + with an existing system. + + Sample array, must be sorted ascendingly. + Quantile selector, between 0.0 and 1.0 (inclusive). + Quantile definition, to choose what product/definition it should be consistent with + + + + Estimates the empirical cumulative distribution function (CDF) at x from the sorted data array (ascending). + + The data sample sequence. + The value where to estimate the CDF at. + + + + Estimates the quantile tau from the sorted data array (ascending). + The tau-th quantile is the data value where the cumulative distribution + function crosses tau. The quantile definition can be specified to be compatible + with an existing system. + + The data sample sequence. + Quantile value. + Rank definition, to choose how ties should be handled and what product/definition it should be consistent with + + + + Evaluates the rank of each entry of the sorted data array (ascending). + The rank definition can be specified to be compatible + with an existing system. + + + + + Returns the smallest value from the sorted data array (ascending). + + Sample array, must be sorted ascendingly. + + + + Returns the largest value from the sorted data array (ascending). + + Sample array, must be sorted ascendingly. + + + + Returns the order statistic (order 1..N) from the sorted data array (ascending). + + Sample array, must be sorted ascendingly. + One-based order of the statistic, must be between 1 and N (inclusive). + + + + Estimates the median value from the sorted data array (ascending). + Approximately median-unbiased regardless of the sample distribution (R8). + + Sample array, must be sorted ascendingly. + + + + Estimates the p-Percentile value from the sorted data array (ascending). + If a non-integer Percentile is needed, use Quantile instead. + Approximately median-unbiased regardless of the sample distribution (R8). + + Sample array, must be sorted ascendingly. + Percentile selector, between 0 and 100 (inclusive). + + + + Estimates the first quartile value from the sorted data array (ascending). + Approximately median-unbiased regardless of the sample distribution (R8). + + Sample array, must be sorted ascendingly. + + + + Estimates the third quartile value from the sorted data array (ascending). + Approximately median-unbiased regardless of the sample distribution (R8). + + Sample array, must be sorted ascendingly. + + + + Estimates the inter-quartile range from the sorted data array (ascending). + Approximately median-unbiased regardless of the sample distribution (R8). + + Sample array, must be sorted ascendingly. + + + + Estimates {min, lower-quantile, median, upper-quantile, max} from the sorted data array (ascending). + Approximately median-unbiased regardless of the sample distribution (R8). + + Sample array, must be sorted ascendingly. + + + + Estimates the tau-th quantile from the sorted data array (ascending). + The tau-th quantile is the data value where the cumulative distribution + function crosses tau. + Approximately median-unbiased regardless of the sample distribution (R8). + + Sample array, must be sorted ascendingly. + Quantile selector, between 0.0 and 1.0 (inclusive). + + R-8, SciPy-(1/3,1/3): + Linear interpolation of the approximate medians for order statistics. + When tau < (2/3) / (N + 1/3), use x1. When tau >= (N - 1/3) / (N + 1/3), use xN. + + + + + Estimates the tau-th quantile from the sorted data array (ascending). + The tau-th quantile is the data value where the cumulative distribution + function crosses tau. The quantile definition can be specified + by 4 parameters a, b, c and d, consistent with Mathematica. + + Sample array, must be sorted ascendingly. + Quantile selector, between 0.0 and 1.0 (inclusive). + a-parameter + b-parameter + c-parameter + d-parameter + + + + Estimates the tau-th quantile from the sorted data array (ascending). + The tau-th quantile is the data value where the cumulative distribution + function crosses tau. The quantile definition can be specified to be compatible + with an existing system. + + Sample array, must be sorted ascendingly. + Quantile selector, between 0.0 and 1.0 (inclusive). + Quantile definition, to choose what product/definition it should be consistent with + + + + Estimates the empirical cumulative distribution function (CDF) at x from the sorted data array (ascending). + + The data sample sequence. + The value where to estimate the CDF at. + + + + Estimates the quantile tau from the sorted data array (ascending). + The tau-th quantile is the data value where the cumulative distribution + function crosses tau. The quantile definition can be specified to be compatible + with an existing system. + + The data sample sequence. + Quantile value. + Rank definition, to choose how ties should be handled and what product/definition it should be consistent with + + + + Evaluates the rank of each entry of the sorted data array (ascending). + The rank definition can be specified to be compatible + with an existing system. + + + + + Extension methods to return basic statistics on set of data. + + + + + Returns the minimum value in the sample data. + Returns NaN if data is empty or if any entry is NaN. + + The sample data. + The minimum value in the sample data. + + + + Returns the minimum value in the sample data. + Returns NaN if data is empty or if any entry is NaN. + + The sample data. + The minimum value in the sample data. + + + + Returns the minimum value in the sample data. + Returns NaN if data is empty or if any entry is NaN. + Null-entries are ignored. + + The sample data. + The minimum value in the sample data. + + + + Returns the maximum value in the sample data. + Returns NaN if data is empty or if any entry is NaN. + + The sample data. + The maximum value in the sample data. + + + + Returns the maximum value in the sample data. + Returns NaN if data is empty or if any entry is NaN. + + The sample data. + The maximum value in the sample data. + + + + Returns the maximum value in the sample data. + Returns NaN if data is empty or if any entry is NaN. + Null-entries are ignored. + + The sample data. + The maximum value in the sample data. + + + + Returns the minimum absolute value in the sample data. + Returns NaN if data is empty or if any entry is NaN. + + The sample data. + The minimum value in the sample data. + + + + Returns the minimum absolute value in the sample data. + Returns NaN if data is empty or if any entry is NaN. + + The sample data. + The minimum value in the sample data. + + + + Returns the maximum absolute value in the sample data. + Returns NaN if data is empty or if any entry is NaN. + + The sample data. + The maximum value in the sample data. + + + + Returns the maximum absolute value in the sample data. + Returns NaN if data is empty or if any entry is NaN. + + The sample data. + The maximum value in the sample data. + + + + Returns the minimum magnitude and phase value in the sample data. + Returns NaN if data is empty or if any entry is NaN. + + The sample data. + The minimum value in the sample data. + + + + Returns the minimum magnitude and phase value in the sample data. + Returns NaN if data is empty or if any entry is NaN. + + The sample data. + The minimum value in the sample data. + + + + Returns the maximum magnitude and phase value in the sample data. + Returns NaN if data is empty or if any entry is NaN. + + The sample data. + The minimum value in the sample data. + + + + Returns the maximum magnitude and phase value in the sample data. + Returns NaN if data is empty or if any entry is NaN. + + The sample data. + The minimum value in the sample data. + + + + Evaluates the sample mean, an estimate of the population mean. + Returns NaN if data is empty or if any entry is NaN. + + The data to calculate the mean of. + The mean of the sample. + + + + Evaluates the sample mean, an estimate of the population mean. + Returns NaN if data is empty or if any entry is NaN. + + The data to calculate the mean of. + The mean of the sample. + + + + Evaluates the sample mean, an estimate of the population mean. + Returns NaN if data is empty or if any entry is NaN. + Null-entries are ignored. + + The data to calculate the mean of. + The mean of the sample. + + + + Evaluates the geometric mean. + Returns NaN if data is empty or if any entry is NaN. + + The data to calculate the geometric mean of. + The geometric mean of the sample. + + + + Evaluates the geometric mean. + Returns NaN if data is empty or if any entry is NaN. + + The data to calculate the geometric mean of. + The geometric mean of the sample. + + + + Evaluates the harmonic mean. + Returns NaN if data is empty or if any entry is NaN. + + The data to calculate the harmonic mean of. + The harmonic mean of the sample. + + + + Evaluates the harmonic mean. + Returns NaN if data is empty or if any entry is NaN. + + The data to calculate the harmonic mean of. + The harmonic mean of the sample. + + + + Estimates the unbiased population variance from the provided samples. + On a dataset of size N will use an N-1 normalizer (Bessel's correction). + Returns NaN if data has less than two entries or if any entry is NaN. + + A subset of samples, sampled from the full population. + + + + Estimates the unbiased population variance from the provided samples. + On a dataset of size N will use an N-1 normalizer (Bessel's correction). + Returns NaN if data has less than two entries or if any entry is NaN. + + A subset of samples, sampled from the full population. + + + + Estimates the unbiased population variance from the provided samples. + On a dataset of size N will use an N-1 normalizer (Bessel's correction). + Returns NaN if data has less than two entries or if any entry is NaN. + Null-entries are ignored. + + A subset of samples, sampled from the full population. + + + + Evaluates the variance from the provided full population. + On a dataset of size N will use an N normalizer and would thus be biased if applied to a subset. + Returns NaN if data is empty or if any entry is NaN. + + The full population data. + + + + Evaluates the variance from the provided full population. + On a dataset of size N will use an N normalizer and would thus be biased if applied to a subset. + Returns NaN if data is empty or if any entry is NaN. + + The full population data. + + + + Evaluates the variance from the provided full population. + On a dataset of size N will use an N normalize and would thus be biased if applied to a subset. + Returns NaN if data is empty or if any entry is NaN. + Null-entries are ignored. + + The full population data. + + + + Estimates the unbiased population standard deviation from the provided samples. + On a dataset of size N will use an N-1 normalizer (Bessel's correction). + Returns NaN if data has less than two entries or if any entry is NaN. + + A subset of samples, sampled from the full population. + + + + Estimates the unbiased population standard deviation from the provided samples. + On a dataset of size N will use an N-1 normalizer (Bessel's correction). + Returns NaN if data has less than two entries or if any entry is NaN. + + A subset of samples, sampled from the full population. + + + + Estimates the unbiased population standard deviation from the provided samples. + On a dataset of size N will use an N-1 normalizer (Bessel's correction). + Returns NaN if data has less than two entries or if any entry is NaN. + Null-entries are ignored. + + A subset of samples, sampled from the full population. + + + + Evaluates the standard deviation from the provided full population. + On a dataset of size N will use an N normalizer and would thus be biased if applied to a subset. + Returns NaN if data is empty or if any entry is NaN. + + The full population data. + + + + Evaluates the standard deviation from the provided full population. + On a dataset of size N will use an N normalizer and would thus be biased if applied to a subset. + Returns NaN if data is empty or if any entry is NaN. + + The full population data. + + + + Evaluates the standard deviation from the provided full population. + On a dataset of size N will use an N normalizer and would thus be biased if applied to a subset. + Returns NaN if data is empty or if any entry is NaN. + Null-entries are ignored. + + The full population data. + + + + Estimates the unbiased population skewness from the provided samples. + Uses a normalizer (Bessel's correction; type 2). + Returns NaN if data has less than three entries or if any entry is NaN. + + A subset of samples, sampled from the full population. + + + + Estimates the unbiased population skewness from the provided samples. + Uses a normalizer (Bessel's correction; type 2). + Returns NaN if data has less than three entries or if any entry is NaN. + Null-entries are ignored. + + A subset of samples, sampled from the full population. + + + + Evaluates the skewness from the full population. + Does not use a normalizer and would thus be biased if applied to a subset (type 1). + Returns NaN if data has less than two entries or if any entry is NaN. + + The full population data. + + + + Evaluates the skewness from the full population. + Does not use a normalizer and would thus be biased if applied to a subset (type 1). + Returns NaN if data has less than two entries or if any entry is NaN. + Null-entries are ignored. + + The full population data. + + + + Estimates the unbiased population kurtosis from the provided samples. + Uses a normalizer (Bessel's correction; type 2). + Returns NaN if data has less than four entries or if any entry is NaN. + + A subset of samples, sampled from the full population. + + + + Estimates the unbiased population kurtosis from the provided samples. + Uses a normalizer (Bessel's correction; type 2). + Returns NaN if data has less than four entries or if any entry is NaN. + Null-entries are ignored. + + A subset of samples, sampled from the full population. + + + + Evaluates the kurtosis from the full population. + Does not use a normalizer and would thus be biased if applied to a subset (type 1). + Returns NaN if data has less than three entries or if any entry is NaN. + + The full population data. + + + + Evaluates the kurtosis from the full population. + Does not use a normalizer and would thus be biased if applied to a subset (type 1). + Returns NaN if data has less than three entries or if any entry is NaN. + Null-entries are ignored. + + The full population data. + + + + Estimates the sample mean and the unbiased population variance from the provided samples. + On a dataset of size N will use an N-1 normalizer (Bessel's correction). + Returns NaN for mean if data is empty or if any entry is NaN and NaN for variance if data has less than two entries or if any entry is NaN. + + The data to calculate the mean of. + The mean of the sample. + + + + Estimates the sample mean and the unbiased population variance from the provided samples. + On a dataset of size N will use an N-1 normalizer (Bessel's correction). + Returns NaN for mean if data is empty or if any entry is NaN and NaN for variance if data has less than two entries or if any entry is NaN. + + The data to calculate the mean of. + The mean of the sample. + + + + Estimates the sample mean and the unbiased population standard deviation from the provided samples. + On a dataset of size N will use an N-1 normalizer (Bessel's correction). + Returns NaN for mean if data is empty or if any entry is NaN and NaN for standard deviation if data has less than two entries or if any entry is NaN. + + The data to calculate the mean of. + The mean of the sample. + + + + Estimates the sample mean and the unbiased population standard deviation from the provided samples. + On a dataset of size N will use an N-1 normalizer (Bessel's correction). + Returns NaN for mean if data is empty or if any entry is NaN and NaN for standard deviation if data has less than two entries or if any entry is NaN. + + The data to calculate the mean of. + The mean of the sample. + + + + Estimates the unbiased population skewness and kurtosis from the provided samples in a single pass. + Uses a normalizer (Bessel's correction; type 2). + + A subset of samples, sampled from the full population. + + + + Evaluates the skewness and kurtosis from the full population. + Does not use a normalizer and would thus be biased if applied to a subset (type 1). + + The full population data. + + + + Estimates the unbiased population covariance from the provided samples. + On a dataset of size N will use an N-1 normalizer (Bessel's correction). + Returns NaN if data has less than two entries or if any entry is NaN. + + A subset of samples, sampled from the full population. + A subset of samples, sampled from the full population. + + + + Estimates the unbiased population covariance from the provided samples. + On a dataset of size N will use an N-1 normalizer (Bessel's correction). + Returns NaN if data has less than two entries or if any entry is NaN. + + A subset of samples, sampled from the full population. + A subset of samples, sampled from the full population. + + + + Estimates the unbiased population covariance from the provided samples. + On a dataset of size N will use an N-1 normalizer (Bessel's correction). + Returns NaN if data has less than two entries or if any entry is NaN. + Null-entries are ignored. + + A subset of samples, sampled from the full population. + A subset of samples, sampled from the full population. + + + + Evaluates the population covariance from the provided full populations. + On a dataset of size N will use an N normalizer and would thus be biased if applied to a subset. + Returns NaN if data is empty or if any entry is NaN. + + The full population data. + The full population data. + + + + Evaluates the population covariance from the provided full populations. + On a dataset of size N will use an N normalizer and would thus be biased if applied to a subset. + Returns NaN if data is empty or if any entry is NaN. + + The full population data. + The full population data. + + + + Evaluates the population covariance from the provided full populations. + On a dataset of size N will use an N normalize and would thus be biased if applied to a subset. + Returns NaN if data is empty or if any entry is NaN. + Null-entries are ignored. + + The full population data. + The full population data. + + + + Evaluates the root mean square (RMS) also known as quadratic mean. + Returns NaN if data is empty or if any entry is NaN. + + The data to calculate the RMS of. + + + + Evaluates the root mean square (RMS) also known as quadratic mean. + Returns NaN if data is empty or if any entry is NaN. + + The data to calculate the RMS of. + + + + Evaluates the root mean square (RMS) also known as quadratic mean. + Returns NaN if data is empty or if any entry is NaN. + Null-entries are ignored. + + The data to calculate the mean of. + + + + Estimates the sample median from the provided samples (R8). + + The data sample sequence. + + + + Estimates the sample median from the provided samples (R8). + + The data sample sequence. + + + + Estimates the sample median from the provided samples (R8). + + The data sample sequence. + + + + Estimates the tau-th quantile from the provided samples. + The tau-th quantile is the data value where the cumulative distribution + function crosses tau. + Approximately median-unbiased regardless of the sample distribution (R8). + + The data sample sequence. + Quantile selector, between 0.0 and 1.0 (inclusive). + + + + Estimates the tau-th quantile from the provided samples. + The tau-th quantile is the data value where the cumulative distribution + function crosses tau. + Approximately median-unbiased regardless of the sample distribution (R8). + + The data sample sequence. + Quantile selector, between 0.0 and 1.0 (inclusive). + + + + Estimates the tau-th quantile from the provided samples. + The tau-th quantile is the data value where the cumulative distribution + function crosses tau. + Approximately median-unbiased regardless of the sample distribution (R8). + + The data sample sequence. + Quantile selector, between 0.0 and 1.0 (inclusive). + + + + Estimates the tau-th quantile from the provided samples. + The tau-th quantile is the data value where the cumulative distribution + function crosses tau. + Approximately median-unbiased regardless of the sample distribution (R8). + + The data sample sequence. + + + + Estimates the tau-th quantile from the provided samples. + The tau-th quantile is the data value where the cumulative distribution + function crosses tau. + Approximately median-unbiased regardless of the sample distribution (R8). + + The data sample sequence. + + + + Estimates the tau-th quantile from the provided samples. + The tau-th quantile is the data value where the cumulative distribution + function crosses tau. + Approximately median-unbiased regardless of the sample distribution (R8). + + The data sample sequence. + + + + Estimates the tau-th quantile from the provided samples. + The tau-th quantile is the data value where the cumulative distribution + function crosses tau. The quantile definition can be specified to be compatible + with an existing system. + + The data sample sequence. + Quantile selector, between 0.0 and 1.0 (inclusive). + Quantile definition, to choose what product/definition it should be consistent with + + + + Estimates the tau-th quantile from the provided samples. + The tau-th quantile is the data value where the cumulative distribution + function crosses tau. The quantile definition can be specified to be compatible + with an existing system. + + The data sample sequence. + Quantile selector, between 0.0 and 1.0 (inclusive). + Quantile definition, to choose what product/definition it should be consistent with + + + + Estimates the tau-th quantile from the provided samples. + The tau-th quantile is the data value where the cumulative distribution + function crosses tau. The quantile definition can be specified to be compatible + with an existing system. + + The data sample sequence. + Quantile selector, between 0.0 and 1.0 (inclusive). + Quantile definition, to choose what product/definition it should be consistent with + + + + Estimates the tau-th quantile from the provided samples. + The tau-th quantile is the data value where the cumulative distribution + function crosses tau. The quantile definition can be specified to be compatible + with an existing system. + + The data sample sequence. + Quantile definition, to choose what product/definition it should be consistent with + + + + Estimates the tau-th quantile from the provided samples. + The tau-th quantile is the data value where the cumulative distribution + function crosses tau. The quantile definition can be specified to be compatible + with an existing system. + + The data sample sequence. + Quantile definition, to choose what product/definition it should be consistent with + + + + Estimates the tau-th quantile from the provided samples. + The tau-th quantile is the data value where the cumulative distribution + function crosses tau. The quantile definition can be specified to be compatible + with an existing system. + + The data sample sequence. + Quantile definition, to choose what product/definition it should be consistent with + + + + Estimates the p-Percentile value from the provided samples. + If a non-integer Percentile is needed, use Quantile instead. + Approximately median-unbiased regardless of the sample distribution (R8). + + The data sample sequence. + Percentile selector, between 0 and 100 (inclusive). + + + + Estimates the p-Percentile value from the provided samples. + If a non-integer Percentile is needed, use Quantile instead. + Approximately median-unbiased regardless of the sample distribution (R8). + + The data sample sequence. + Percentile selector, between 0 and 100 (inclusive). + + + + Estimates the p-Percentile value from the provided samples. + If a non-integer Percentile is needed, use Quantile instead. + Approximately median-unbiased regardless of the sample distribution (R8). + + The data sample sequence. + Percentile selector, between 0 and 100 (inclusive). + + + + Estimates the p-Percentile value from the provided samples. + If a non-integer Percentile is needed, use Quantile instead. + Approximately median-unbiased regardless of the sample distribution (R8). + + The data sample sequence. + + + + Estimates the p-Percentile value from the provided samples. + If a non-integer Percentile is needed, use Quantile instead. + Approximately median-unbiased regardless of the sample distribution (R8). + + The data sample sequence. + + + + Estimates the p-Percentile value from the provided samples. + If a non-integer Percentile is needed, use Quantile instead. + Approximately median-unbiased regardless of the sample distribution (R8). + + The data sample sequence. + + + + Estimates the first quartile value from the provided samples. + Approximately median-unbiased regardless of the sample distribution (R8). + + The data sample sequence. + + + + Estimates the first quartile value from the provided samples. + Approximately median-unbiased regardless of the sample distribution (R8). + + The data sample sequence. + + + + Estimates the first quartile value from the provided samples. + Approximately median-unbiased regardless of the sample distribution (R8). + + The data sample sequence. + + + + Estimates the third quartile value from the provided samples. + Approximately median-unbiased regardless of the sample distribution (R8). + + The data sample sequence. + + + + Estimates the third quartile value from the provided samples. + Approximately median-unbiased regardless of the sample distribution (R8). + + The data sample sequence. + + + + Estimates the third quartile value from the provided samples. + Approximately median-unbiased regardless of the sample distribution (R8). + + The data sample sequence. + + + + Estimates the inter-quartile range from the provided samples. + Approximately median-unbiased regardless of the sample distribution (R8). + + The data sample sequence. + + + + Estimates the inter-quartile range from the provided samples. + Approximately median-unbiased regardless of the sample distribution (R8). + + The data sample sequence. + + + + Estimates the inter-quartile range from the provided samples. + Approximately median-unbiased regardless of the sample distribution (R8). + + The data sample sequence. + + + + Estimates {min, lower-quantile, median, upper-quantile, max} from the provided samples. + Approximately median-unbiased regardless of the sample distribution (R8). + + The data sample sequence. + + + + Estimates {min, lower-quantile, median, upper-quantile, max} from the provided samples. + Approximately median-unbiased regardless of the sample distribution (R8). + + The data sample sequence. + + + + Estimates {min, lower-quantile, median, upper-quantile, max} from the provided samples. + Approximately median-unbiased regardless of the sample distribution (R8). + + The data sample sequence. + + + + Returns the order statistic (order 1..N) from the provided samples. + + The data sample sequence. + One-based order of the statistic, must be between 1 and N (inclusive). + + + + Returns the order statistic (order 1..N) from the provided samples. + + The data sample sequence. + One-based order of the statistic, must be between 1 and N (inclusive). + + + + Returns the order statistic (order 1..N) from the provided samples. + + The data sample sequence. + + + + Returns the order statistic (order 1..N) from the provided samples. + + The data sample sequence. + + + + Evaluates the rank of each entry of the provided samples. + The rank definition can be specified to be compatible + with an existing system. + + The data sample sequence. + Rank definition, to choose how ties should be handled and what product/definition it should be consistent with + + + + Evaluates the rank of each entry of the provided samples. + The rank definition can be specified to be compatible + with an existing system. + + The data sample sequence. + Rank definition, to choose how ties should be handled and what product/definition it should be consistent with + + + + Evaluates the rank of each entry of the provided samples. + The rank definition can be specified to be compatible + with an existing system. + + The data sample sequence. + Rank definition, to choose how ties should be handled and what product/definition it should be consistent with + + + + Estimates the quantile tau from the provided samples. + The tau-th quantile is the data value where the cumulative distribution + function crosses tau. The quantile definition can be specified to be compatible + with an existing system. + + The data sample sequence. + Quantile value. + Rank definition, to choose how ties should be handled and what product/definition it should be consistent with + + + + Estimates the quantile tau from the provided samples. + The tau-th quantile is the data value where the cumulative distribution + function crosses tau. The quantile definition can be specified to be compatible + with an existing system. + + The data sample sequence. + Quantile value. + Rank definition, to choose how ties should be handled and what product/definition it should be consistent with + + + + Estimates the quantile tau from the provided samples. + The tau-th quantile is the data value where the cumulative distribution + function crosses tau. The quantile definition can be specified to be compatible + with an existing system. + + The data sample sequence. + Quantile value. + Rank definition, to choose how ties should be handled and what product/definition it should be consistent with + + + + Estimates the quantile tau from the provided samples. + The tau-th quantile is the data value where the cumulative distribution + function crosses tau. The quantile definition can be specified to be compatible + with an existing system. + + The data sample sequence. + Rank definition, to choose how ties should be handled and what product/definition it should be consistent with + + + + Estimates the quantile tau from the provided samples. + The tau-th quantile is the data value where the cumulative distribution + function crosses tau. The quantile definition can be specified to be compatible + with an existing system. + + The data sample sequence. + Rank definition, to choose how ties should be handled and what product/definition it should be consistent with + + + + Estimates the quantile tau from the provided samples. + The tau-th quantile is the data value where the cumulative distribution + function crosses tau. The quantile definition can be specified to be compatible + with an existing system. + + The data sample sequence. + Rank definition, to choose how ties should be handled and what product/definition it should be consistent with + + + + Estimates the empirical cumulative distribution function (CDF) at x from the provided samples. + + The data sample sequence. + The value where to estimate the CDF at. + + + + Estimates the empirical cumulative distribution function (CDF) at x from the provided samples. + + The data sample sequence. + The value where to estimate the CDF at. + + + + Estimates the empirical cumulative distribution function (CDF) at x from the provided samples. + + The data sample sequence. + The value where to estimate the CDF at. + + + + Estimates the empirical cumulative distribution function (CDF) at x from the provided samples. + + The data sample sequence. + + + + Estimates the empirical cumulative distribution function (CDF) at x from the provided samples. + + The data sample sequence. + + + + Estimates the empirical cumulative distribution function (CDF) at x from the provided samples. + + The data sample sequence. + + + + Estimates the empirical inverse CDF at tau from the provided samples. + + The data sample sequence. + Quantile selector, between 0.0 and 1.0 (inclusive). + + + + Estimates the empirical inverse CDF at tau from the provided samples. + + The data sample sequence. + Quantile selector, between 0.0 and 1.0 (inclusive). + + + + Estimates the empirical inverse CDF at tau from the provided samples. + + The data sample sequence. + Quantile selector, between 0.0 and 1.0 (inclusive). + + + + Estimates the empirical inverse CDF at tau from the provided samples. + + The data sample sequence. + + + + Estimates the empirical inverse CDF at tau from the provided samples. + + The data sample sequence. + + + + Estimates the empirical inverse CDF at tau from the provided samples. + + The data sample sequence. + + + + Calculates the entropy of a stream of double values in bits. + Returns NaN if any of the values in the stream are NaN. + + The data sample sequence. + + + + Calculates the entropy of a stream of double values in bits. + Returns NaN if any of the values in the stream are NaN. + Null-entries are ignored. + + The data sample sequence. + + + + Evaluates the sample mean over a moving window, for each samples. + Returns NaN if no data is empty or if any entry is NaN. + + The sample stream to calculate the mean of. + The number of last samples to consider. + + + + Statistics operating on an IEnumerable in a single pass, without keeping the full data in memory. + Can be used in a streaming way, e.g. on large datasets not fitting into memory. + + + + + + + + Returns the smallest value from the enumerable, in a single pass without memoization. + Returns NaN if data is empty or any entry is NaN. + + Sample stream, no sorting is assumed. + + + + Returns the smallest value from the enumerable, in a single pass without memoization. + Returns NaN if data is empty or any entry is NaN. + + Sample stream, no sorting is assumed. + + + + Returns the largest value from the enumerable, in a single pass without memoization. + Returns NaN if data is empty or any entry is NaN. + + Sample stream, no sorting is assumed. + + + + Returns the largest value from the enumerable, in a single pass without memoization. + Returns NaN if data is empty or any entry is NaN. + + Sample stream, no sorting is assumed. + + + + Returns the smallest absolute value from the enumerable, in a single pass without memoization. + Returns NaN if data is empty or any entry is NaN. + + Sample stream, no sorting is assumed. + + + + Returns the smallest absolute value from the enumerable, in a single pass without memoization. + Returns NaN if data is empty or any entry is NaN. + + Sample stream, no sorting is assumed. + + + + Returns the largest absolute value from the enumerable, in a single pass without memoization. + Returns NaN if data is empty or any entry is NaN. + + Sample stream, no sorting is assumed. + + + + Returns the largest absolute value from the enumerable, in a single pass without memoization. + Returns NaN if data is empty or any entry is NaN. + + Sample stream, no sorting is assumed. + + + + Returns the smallest absolute value from the enumerable, in a single pass without memoization. + Returns NaN if data is empty or any entry is NaN. + + Sample stream, no sorting is assumed. + + + + Returns the smallest absolute value from the enumerable, in a single pass without memoization. + Returns NaN if data is empty or any entry is NaN. + + Sample stream, no sorting is assumed. + + + + Returns the largest absolute value from the enumerable, in a single pass without memoization. + Returns NaN if data is empty or any entry is NaN. + + Sample stream, no sorting is assumed. + + + + Returns the largest absolute value from the enumerable, in a single pass without memoization. + Returns NaN if data is empty or any entry is NaN. + + Sample stream, no sorting is assumed. + + + + Estimates the arithmetic sample mean from the enumerable, in a single pass without memoization. + Returns NaN if data is empty or any entry is NaN. + + Sample stream, no sorting is assumed. + + + + Estimates the arithmetic sample mean from the enumerable, in a single pass without memoization. + Returns NaN if data is empty or any entry is NaN. + + Sample stream, no sorting is assumed. + + + + Evaluates the geometric mean of the enumerable, in a single pass without memoization. + Returns NaN if data is empty or any entry is NaN. + + Sample stream, no sorting is assumed. + + + + Evaluates the geometric mean of the enumerable, in a single pass without memoization. + Returns NaN if data is empty or any entry is NaN. + + Sample stream, no sorting is assumed. + + + + Evaluates the harmonic mean of the enumerable, in a single pass without memoization. + Returns NaN if data is empty or any entry is NaN. + + Sample stream, no sorting is assumed. + + + + Evaluates the harmonic mean of the enumerable, in a single pass without memoization. + Returns NaN if data is empty or any entry is NaN. + + Sample stream, no sorting is assumed. + + + + Estimates the unbiased population variance from the provided samples as enumerable sequence, in a single pass without memoization. + On a dataset of size N will use an N-1 normalizer (Bessel's correction). + Returns NaN if data has less than two entries or if any entry is NaN. + + Sample stream, no sorting is assumed. + + + + Estimates the unbiased population variance from the provided samples as enumerable sequence, in a single pass without memoization. + On a dataset of size N will use an N-1 normalizer (Bessel's correction). + Returns NaN if data has less than two entries or if any entry is NaN. + + Sample stream, no sorting is assumed. + + + + Evaluates the population variance from the full population provided as enumerable sequence, in a single pass without memoization. + On a dataset of size N will use an N normalizer and would thus be biased if applied to a subset. + Returns NaN if data is empty or if any entry is NaN. + + Sample stream, no sorting is assumed. + + + + Evaluates the population variance from the full population provided as enumerable sequence, in a single pass without memoization. + On a dataset of size N will use an N normalizer and would thus be biased if applied to a subset. + Returns NaN if data is empty or if any entry is NaN. + + Sample stream, no sorting is assumed. + + + + Estimates the unbiased population standard deviation from the provided samples as enumerable sequence, in a single pass without memoization. + On a dataset of size N will use an N-1 normalizer (Bessel's correction). + Returns NaN if data has less than two entries or if any entry is NaN. + + Sample stream, no sorting is assumed. + + + + Estimates the unbiased population standard deviation from the provided samples as enumerable sequence, in a single pass without memoization. + On a dataset of size N will use an N-1 normalizer (Bessel's correction). + Returns NaN if data has less than two entries or if any entry is NaN. + + Sample stream, no sorting is assumed. + + + + Evaluates the population standard deviation from the full population provided as enumerable sequence, in a single pass without memoization. + On a dataset of size N will use an N normalizer and would thus be biased if applied to a subset. + Returns NaN if data is empty or if any entry is NaN. + + Sample stream, no sorting is assumed. + + + + Evaluates the population standard deviation from the full population provided as enumerable sequence, in a single pass without memoization. + On a dataset of size N will use an N normalizer and would thus be biased if applied to a subset. + Returns NaN if data is empty or if any entry is NaN. + + Sample stream, no sorting is assumed. + + + + Estimates the arithmetic sample mean and the unbiased population variance from the provided samples as enumerable sequence, in a single pass without memoization. + On a dataset of size N will use an N-1 normalizer (Bessel's correction). + Returns NaN for mean if data is empty or any entry is NaN, and NaN for variance if data has less than two entries or if any entry is NaN. + + Sample stream, no sorting is assumed. + + + + Estimates the arithmetic sample mean and the unbiased population variance from the provided samples as enumerable sequence, in a single pass without memoization. + On a dataset of size N will use an N-1 normalizer (Bessel's correction). + Returns NaN for mean if data is empty or any entry is NaN, and NaN for variance if data has less than two entries or if any entry is NaN. + + Sample stream, no sorting is assumed. + + + + Estimates the arithmetic sample mean and the unbiased population standard deviation from the provided samples as enumerable sequence, in a single pass without memoization. + On a dataset of size N will use an N-1 normalizer (Bessel's correction). + Returns NaN for mean if data is empty or any entry is NaN, and NaN for standard deviation if data has less than two entries or if any entry is NaN. + + Sample stream, no sorting is assumed. + + + + Estimates the arithmetic sample mean and the unbiased population standard deviation from the provided samples as enumerable sequence, in a single pass without memoization. + On a dataset of size N will use an N-1 normalizer (Bessel's correction). + Returns NaN for mean if data is empty or any entry is NaN, and NaN for standard deviation if data has less than two entries or if any entry is NaN. + + Sample stream, no sorting is assumed. + + + + Estimates the unbiased population covariance from the provided two sample enumerable sequences, in a single pass without memoization. + On a dataset of size N will use an N-1 normalizer (Bessel's correction). + Returns NaN if data has less than two entries or if any entry is NaN. + + First sample stream. + Second sample stream. + + + + Estimates the unbiased population covariance from the provided two sample enumerable sequences, in a single pass without memoization. + On a dataset of size N will use an N-1 normalizer (Bessel's correction). + Returns NaN if data has less than two entries or if any entry is NaN. + + First sample stream. + Second sample stream. + + + + Evaluates the population covariance from the full population provided as two enumerable sequences, in a single pass without memoization. + On a dataset of size N will use an N normalizer and would thus be biased if applied to a subset. + Returns NaN if data is empty or if any entry is NaN. + + First population stream. + Second population stream. + + + + Evaluates the population covariance from the full population provided as two enumerable sequences, in a single pass without memoization. + On a dataset of size N will use an N normalizer and would thus be biased if applied to a subset. + Returns NaN if data is empty or if any entry is NaN. + + First population stream. + Second population stream. + + + + Estimates the root mean square (RMS) also known as quadratic mean from the enumerable, in a single pass without memoization. + Returns NaN if data is empty or any entry is NaN. + + Sample stream, no sorting is assumed. + + + + Estimates the root mean square (RMS) also known as quadratic mean from the enumerable, in a single pass without memoization. + Returns NaN if data is empty or any entry is NaN. + + Sample stream, no sorting is assumed. + + + + Calculates the entropy of a stream of double values. + Returns NaN if any of the values in the stream are NaN. + + The input stream to evaluate. + + + + + Computes the basic statistics of data set. The class meets the + NIST standard of accuracy for mean, variance, and standard deviation + (the only statistics they provide exact values for) and exceeds them + in increased accuracy mode. + Recommendation: consider to use RunningWeightedStatistics instead. + + + This type declares a DataContract for out of the box ephemeral serialization + with engines like DataContractSerializer, Protocol Buffers and FsPickler, + but does not guarantee any compatibility between versions. + It is not recommended to rely on this mechanism for durable persistence. + + + + + Initializes a new instance of the class. + + The sample data. + + If set to true, increased accuracy mode used. + Increased accuracy mode uses types for internal calculations. + + + Don't use increased accuracy for data sets containing large values (in absolute value). + This may cause the calculations to overflow. + + + + + Initializes a new instance of the class. + + The sample data. + + If set to true, increased accuracy mode used. + Increased accuracy mode uses types for internal calculations. + + + Don't use increased accuracy for data sets containing large values (in absolute value). + This may cause the calculations to overflow. + + + + + Gets the size of the sample. + + The size of the sample. + + + + Gets the sample mean. + + The sample mean. + + + + Gets the unbiased population variance estimator (on a dataset of size N will use an N-1 normalizer). + + The sample variance. + + + + Gets the unbiased population standard deviation (on a dataset of size N will use an N-1 normalizer). + + The sample standard deviation. + + + + Gets the unbiased estimator of the population skewness. + + The sample skewness. + Returns zero if is less than three. + + + + Gets the unbiased estimator of the population excess kurtosis using the G_2 estimator. + + The sample kurtosis. + Returns zero if is less than four. + + + + Gets the maximum sample value. + + The maximum sample value. + + + + Gets the minimum sample value. + + The minimum sample value. + + + + Gets the total weight. When used with unweighted data, returns the number of samples. + + The total weight. + + + + The Kish's effective sample size https://en.wikipedia.org/wiki/Effective_sample_size + + The Kish's effective sample size. + + + + Computes descriptive statistics from a stream of data values and reliability weights. + + A sequence of datapoints. + + + + Computes descriptive statistics from a stream of data values and reliability weights. + + A sequence of datapoints. + + + + Internal use. Method use for setting the statistics. + + For setting Mean. + For setting Variance. + For setting Skewness. + For setting Kurtosis. + For setting Minimum. + For setting Maximum. + For setting Count. + + + + Used to simplify parallel code, particularly between the .NET 4.0 and Silverlight Code. + + + + + Executes a for loop in which iterations may run in parallel. + + The start index, inclusive. + The end index, exclusive. + The body to be invoked for each iteration range. + + + + Executes a for loop in which iterations may run in parallel. + + The start index, inclusive. + The end index, exclusive. + The partition size for splitting work into smaller pieces. + The body to be invoked for each iteration range. + + + + Executes each of the provided actions inside a discrete, asynchronous task. + + An array of actions to execute. + The actions array contains a null element. + At least one invocation of the actions threw an exception. + + + + Selects an item (such as Max or Min). + + Starting index of the loop. + Ending index of the loop + The function to select items over a subset. + The function to select the item of selection from the subsets. + The selected value. + + + + Selects an item (such as Max or Min). + + The array to iterate over. + The function to select items over a subset. + The function to select the item of selection from the subsets. + The selected value. + + + + Selects an item (such as Max or Min). + + Starting index of the loop. + Ending index of the loop + The function to select items over a subset. + The function to select the item of selection from the subsets. + Default result of the reduce function on an empty set. + The selected value. + + + + Selects an item (such as Max or Min). + + The array to iterate over. + The function to select items over a subset. + The function to select the item of selection from the subsets. + Default result of the reduce function on an empty set. + The selected value. + + + + Double-precision trigonometry toolkit. + + + + + Constant to convert a degree to grad. + + + + + Converts a degree (360-periodic) angle to a grad (400-periodic) angle. + + The degree to convert. + The converted grad angle. + + + + Converts a degree (360-periodic) angle to a radian (2*Pi-periodic) angle. + + The degree to convert. + The converted radian angle. + + + + Converts a grad (400-periodic) angle to a degree (360-periodic) angle. + + The grad to convert. + The converted degree. + + + + Converts a grad (400-periodic) angle to a radian (2*Pi-periodic) angle. + + The grad to convert. + The converted radian. + + + + Converts a radian (2*Pi-periodic) angle to a degree (360-periodic) angle. + + The radian to convert. + The converted degree. + + + + Converts a radian (2*Pi-periodic) angle to a grad (400-periodic) angle. + + The radian to convert. + The converted grad. + + + + Normalized Sinc function. sinc(x) = sin(pi*x)/(pi*x). + + + + + Trigonometric Sine of an angle in radian, or opposite / hypotenuse. + + The angle in radian. + The sine of the radian angle. + + + + Trigonometric Sine of a Complex number. + + The complex value. + The sine of the complex number. + + + + Trigonometric Cosine of an angle in radian, or adjacent / hypotenuse. + + The angle in radian. + The cosine of an angle in radian. + + + + Trigonometric Cosine of a Complex number. + + The complex value. + The cosine of a complex number. + + + + Trigonometric Tangent of an angle in radian, or opposite / adjacent. + + The angle in radian. + The tangent of the radian angle. + + + + Trigonometric Tangent of a Complex number. + + The complex value. + The tangent of the complex number. + + + + Trigonometric Cotangent of an angle in radian, or adjacent / opposite. Reciprocal of the tangent. + + The angle in radian. + The cotangent of an angle in radian. + + + + Trigonometric Cotangent of a Complex number. + + The complex value. + The cotangent of the complex number. + + + + Trigonometric Secant of an angle in radian, or hypotenuse / adjacent. Reciprocal of the cosine. + + The angle in radian. + The secant of the radian angle. + + + + Trigonometric Secant of a Complex number. + + The complex value. + The secant of the complex number. + + + + Trigonometric Cosecant of an angle in radian, or hypotenuse / opposite. Reciprocal of the sine. + + The angle in radian. + Cosecant of an angle in radian. + + + + Trigonometric Cosecant of a Complex number. + + The complex value. + The cosecant of a complex number. + + + + Trigonometric principal Arc Sine in radian + + The opposite for a unit hypotenuse (i.e. opposite / hypotenuse). + The angle in radian. + + + + Trigonometric principal Arc Sine of this Complex number. + + The complex value. + The arc sine of a complex number. + + + + Trigonometric principal Arc Cosine in radian + + The adjacent for a unit hypotenuse (i.e. adjacent / hypotenuse). + The angle in radian. + + + + Trigonometric principal Arc Cosine of this Complex number. + + The complex value. + The arc cosine of a complex number. + + + + Trigonometric principal Arc Tangent in radian + + The opposite for a unit adjacent (i.e. opposite / adjacent). + The angle in radian. + + + + Trigonometric principal Arc Tangent of this Complex number. + + The complex value. + The arc tangent of a complex number. + + + + Trigonometric principal Arc Cotangent in radian + + The adjacent for a unit opposite (i.e. adjacent / opposite). + The angle in radian. + + + + Trigonometric principal Arc Cotangent of this Complex number. + + The complex value. + The arc cotangent of a complex number. + + + + Trigonometric principal Arc Secant in radian + + The hypotenuse for a unit adjacent (i.e. hypotenuse / adjacent). + The angle in radian. + + + + Trigonometric principal Arc Secant of this Complex number. + + The complex value. + The arc secant of a complex number. + + + + Trigonometric principal Arc Cosecant in radian + + The hypotenuse for a unit opposite (i.e. hypotenuse / opposite). + The angle in radian. + + + + Trigonometric principal Arc Cosecant of this Complex number. + + The complex value. + The arc cosecant of a complex number. + + + + Hyperbolic Sine + + The hyperbolic angle, i.e. the area of the hyperbolic sector. + The hyperbolic sine of the angle. + + + + Hyperbolic Sine of a Complex number. + + The complex value. + The hyperbolic sine of a complex number. + + + + Hyperbolic Cosine + + The hyperbolic angle, i.e. the area of the hyperbolic sector. + The hyperbolic Cosine of the angle. + + + + Hyperbolic Cosine of a Complex number. + + The complex value. + The hyperbolic cosine of a complex number. + + + + Hyperbolic Tangent in radian + + The hyperbolic angle, i.e. the area of the hyperbolic sector. + The hyperbolic tangent of the angle. + + + + Hyperbolic Tangent of a Complex number. + + The complex value. + The hyperbolic tangent of a complex number. + + + + Hyperbolic Cotangent + + The hyperbolic angle, i.e. the area of the hyperbolic sector. + The hyperbolic cotangent of the angle. + + + + Hyperbolic Cotangent of a Complex number. + + The complex value. + The hyperbolic cotangent of a complex number. + + + + Hyperbolic Secant + + The hyperbolic angle, i.e. the area of the hyperbolic sector. + The hyperbolic secant of the angle. + + + + Hyperbolic Secant of a Complex number. + + The complex value. + The hyperbolic secant of a complex number. + + + + Hyperbolic Cosecant + + The hyperbolic angle, i.e. the area of the hyperbolic sector. + The hyperbolic cosecant of the angle. + + + + Hyperbolic Cosecant of a Complex number. + + The complex value. + The hyperbolic cosecant of a complex number. + + + + Hyperbolic Area Sine + + The real value. + The hyperbolic angle, i.e. the area of its hyperbolic sector. + + + + Hyperbolic Area Sine of this Complex number. + + The complex value. + The hyperbolic arc sine of a complex number. + + + + Hyperbolic Area Cosine + + The real value. + The hyperbolic angle, i.e. the area of its hyperbolic sector. + + + + Hyperbolic Area Cosine of this Complex number. + + The complex value. + The hyperbolic arc cosine of a complex number. + + + + Hyperbolic Area Tangent + + The real value. + The hyperbolic angle, i.e. the area of its hyperbolic sector. + + + + Hyperbolic Area Tangent of this Complex number. + + The complex value. + The hyperbolic arc tangent of a complex number. + + + + Hyperbolic Area Cotangent + + The real value. + The hyperbolic angle, i.e. the area of its hyperbolic sector. + + + + Hyperbolic Area Cotangent of this Complex number. + + The complex value. + The hyperbolic arc cotangent of a complex number. + + + + Hyperbolic Area Secant + + The real value. + The hyperbolic angle, i.e. the area of its hyperbolic sector. + + + + Hyperbolic Area Secant of this Complex number. + + The complex value. + The hyperbolic arc secant of a complex number. + + + + Hyperbolic Area Cosecant + + The real value. + The hyperbolic angle, i.e. the area of its hyperbolic sector. + + + + Hyperbolic Area Cosecant of this Complex number. + + The complex value. + The hyperbolic arc cosecant of a complex number. + + + + Hamming window. Named after Richard Hamming. + Symmetric version, useful e.g. for filter design purposes. + + + + + Hamming window. Named after Richard Hamming. + Periodic version, useful e.g. for FFT purposes. + + + + + Hann window. Named after Julius von Hann. + Symmetric version, useful e.g. for filter design purposes. + + + + + Hann window. Named after Julius von Hann. + Periodic version, useful e.g. for FFT purposes. + + + + + Cosine window. + Symmetric version, useful e.g. for filter design purposes. + + + + + Cosine window. + Periodic version, useful e.g. for FFT purposes. + + + + + Lanczos window. + Symmetric version, useful e.g. for filter design purposes. + + + + + Lanczos window. + Periodic version, useful e.g. for FFT purposes. + + + + + Gauss window. + + + + + Blackman window. + + + + + Blackman-Harris window. + + + + + Blackman-Nuttall window. + + + + + Bartlett window. + + + + + Bartlett-Hann window. + + + + + Nuttall window. + + + + + Flat top window. + + + + + Uniform rectangular (Dirichlet) window. + + + + + Triangular window. + + + + + Tukey tapering window. A rectangular window bounded + by half a cosine window on each side. + + Width of the window + Fraction of the window occupied by the cosine parts + +     +     diff --git a/Runtime/Player/CameraController.cs b/Runtime/Player/CameraController.cs new file mode 100644 index 0000000..dd4081d --- /dev/null +++ b/Runtime/Player/CameraController.cs @@ -0,0 +1,293 @@ +#if CREST_UNITY_INPUT && ENABLE_INPUT_SYSTEM +#define INPUT_SYSTEM_ENABLED +#endif + +using System; +using UnityEngine; +#if INPUT_SYSTEM_ENABLED +using UnityEngine.InputSystem; +#endif +#if ENABLE_VR && ENABLE_VR_MODULE +using UnityEngine.XR; +#endif + +namespace Deconstruction.Runtime.Player +{ + /// + /// 一个简单且功能有限的摄像机脚本，可通过 WASD 键和鼠标进行控制。 + /// + public class CameraController : MonoBehaviour + { + /// + /// 此资产的版本。可用于不同版本之间的迁移。只有在编辑器升级版本时才应更改此值。 + /// + [SerializeField, HideInInspector] +#pragma warning disable 414 + int _version = 0; +#pragma warning restore 414 + + public float linSpeed = 10f; + public float rotSpeed = 70f; + + public bool simForwardInput = false; + public bool _requireLMBToMove = false; + + public bool enableWalkMode = false; + + Vector2 _lastMousePos = -Vector2.one; + bool _dragging = false; + + public float _fixedDt = 1 / 60f; + + Transform _targetTransform; + + public CharacterController _moveComponent; + + [Space(10)] + + [SerializeField] + DebugFields _debug = new DebugFields(); + +#pragma warning disable CS0108 + // 在编辑器中，我们需要使用“new”来屏蔽警告，但在构建时会再次给出警告，所以应该使用“pragma”来替代。 + private Camera camera; +#pragma warning restore CS0108 + + [System.Serializable] + class DebugFields + { + [Tooltip("Allows the camera to roll (rotating on the z axis).")] + public bool _enableCameraRoll = false; + + [Tooltip("Disables the XR occlusion mesh for debugging purposes. Only works with legacy XR.")] + public bool _disableOcclusionMesh = false; + + [Tooltip("Sets the XR occlusion mesh scale. Useful for debugging refractions. Only works with legacy XR."), UnityEngine.Range(1f, 2f)] + public float _occlusionMeshScale = 1f; + } + + private void OnValidate() + { + if (_moveComponent == null) + { + _moveComponent = GetComponent(); + } + else if (Application.isEditor) + { + _moveComponent.enabled = enableWalkMode; + } + } + + void Awake() + { + _targetTransform = transform; + + if (!TryGetComponent(out camera)) + { + enabled = false; + return; + } + + if (_moveComponent != null) + { + _moveComponent.enabled = enableWalkMode; + } +#if ENABLE_VR && ENABLE_VR_MODULE + if (XRSettings.enabled) + { + // Seems like the best place to put this for now. Most XR debugging happens using this component. + // @FixMe: useOcclusionMesh doesn't work anymore. Might be a Unity bug. + XRSettings.useOcclusionMesh = !_debug._disableOcclusionMesh; + XRSettings.occlusionMaskScale = _debug._occlusionMeshScale; + } +#endif + } + + void Update() + { + float dt = Time.deltaTime; + if (_fixedDt > 0f) + dt = _fixedDt; + + UpdateMovement(dt); + +#if ENABLE_VR && ENABLE_VR_MODULE + // These aren't useful and can break for XR hardware. + if (!XRSettings.enabled || XRSettings.loadedDeviceName.Contains("MockHMD")) +#endif + { + UpdateDragging(dt); + UpdateKillRoll(); + } + +#if ENABLE_VR && ENABLE_VR_MODULE + if (XRSettings.enabled) + { + // Check if property has changed. + if (XRSettings.useOcclusionMesh == _debug._disableOcclusionMesh) + { + // @FixMe: useOcclusionMesh doesn't work anymore. Might be a Unity bug. + XRSettings.useOcclusionMesh = !_debug._disableOcclusionMesh; + } + + XRSettings.occlusionMaskScale = _debug._occlusionMeshScale; + } +#endif + } + + void UpdateMovement(float dt) + { + // New input system works even when game view is not focused. + if (!Application.isFocused) + { + return; + } + +#if INPUT_SYSTEM_ENABLED + if (!Mouse.current.leftButton.isPressed && _requireLMBToMove) return; + float forward = (Keyboard.current.wKey.isPressed ? 1 : 0) - (Keyboard.current.sKey.isPressed ? 1 : 0); +#else + if (!Input.GetMouseButton(1) && _requireLMBToMove) return; + float forward = (Input.GetKey(KeyCode.W) ? 1 : 0) - (Input.GetKey(KeyCode.S) ? 1 : 0); +#endif + if (simForwardInput) + { + forward = 1f; + } + + _targetTransform.position += linSpeed * _targetTransform.forward * forward * dt; + var speed = linSpeed; + +#if INPUT_SYSTEM_ENABLED + if (Keyboard.current.leftShiftKey.isPressed) +#else + if (Input.GetKey(KeyCode.LeftShift)) +#endif + { + speed *= 3f; + } + + var offset = _targetTransform.forward * forward; + // _targetTransform.position += speed * _targetTransform.forward * forward * dt; + //_transform.position += linSpeed * _transform.right * Input.GetAxis( "Horizontal" ) * dt; +#if INPUT_SYSTEM_ENABLED + offset += _targetTransform.up * (Keyboard.current.eKey.isPressed ? 1 : 0); + offset -= _targetTransform.up * (Keyboard.current.qKey.isPressed ? 1 : 0); + offset -= _targetTransform.right * (Keyboard.current.aKey.isPressed ? 1 : 0); + offset += _targetTransform.right * (Keyboard.current.dKey.isPressed ? 1 : 0); +#else + offset += _targetTransform.up * (Input.GetKey(KeyCode.E) ? 1 : 0); + offset -= _targetTransform.up * (Input.GetKey(KeyCode.Q) ? 1 : 0); + offset -= _targetTransform.right * (Input.GetKey(KeyCode.A) ? 1 : 0); + offset += _targetTransform.right * (Input.GetKey(KeyCode.D) ? 1 : 0); +#endif + offset *= speed * dt; + + // 使用控制器移动 + if (enableWalkMode) + { + UpdateWalk(offset); + } + // 直接设置坐标移动 + else + { + _targetTransform.position += offset; + } + { + float rotate = 0f; +#if INPUT_SYSTEM_ENABLED + rotate += (Keyboard.current.rightArrowKey.isPressed ? 1 : 0); + rotate -= (Keyboard.current.leftArrowKey.isPressed ? 1 : 0); +#else + rotate += (Input.GetKey(KeyCode.RightArrow) ? 1 : 0); + rotate -= (Input.GetKey(KeyCode.LeftArrow) ? 1 : 0); +#endif + + rotate *= 5f; + Vector3 ea = _targetTransform.eulerAngles; + ea.y += 0.1f * rotSpeed * rotate * dt; + _targetTransform.eulerAngles = ea; + } + } + + void UpdateDragging(float dt) + { + // New input system works even when game view is not focused. + if (!Application.isFocused) + { + return; + } + + Vector2 mousePos = +#if INPUT_SYSTEM_ENABLED + Mouse.current.position.ReadValue(); +#else + Input.mousePosition; +#endif + + var wasLeftMouseButtonPressed = +#if INPUT_SYSTEM_ENABLED + Mouse.current.leftButton.wasPressedThisFrame; +#else + Input.GetMouseButtonDown(1); +#endif + + if (!_dragging && wasLeftMouseButtonPressed && camera.rect.Contains(camera.ScreenToViewportPoint(mousePos)) ) + //!Crest.OceanDebugGUI.OverGUI(mousePos)) + { + _dragging = true; + _lastMousePos = mousePos; + } +#if INPUT_SYSTEM_ENABLED + if (_dragging && Mouse.current.leftButton.wasReleasedThisFrame) +#else + if (_dragging && Input.GetMouseButtonUp(1)) +#endif + { + _dragging = false; + _lastMousePos = -Vector2.one; + } + + if (_dragging) + { + Vector2 delta = mousePos - _lastMousePos; + + Vector3 ea = _targetTransform.eulerAngles; + ea.x += -0.1f * rotSpeed * delta.y * dt; + ea.y += 0.1f * rotSpeed * delta.x * dt; + _targetTransform.eulerAngles = ea; + + _lastMousePos = mousePos; + } + } + + void UpdateKillRoll() + { + if (_debug._enableCameraRoll) return; + Vector3 ea = _targetTransform.eulerAngles; + ea.z = 0f; + transform.eulerAngles = ea; + } + + private float gravity = 0; + void UpdateWalk(Vector3 offset) + { + if (_moveComponent != null) + { + _moveComponent.enabled = enableWalkMode; + if (enableWalkMode) + { + if (offset.y > 0) + gravity = 0; + else + { + gravity -= 0.01f; + gravity = Mathf.Max(gravity, -0.98f); + } + offset.y = offset.y <= 0 ? gravity : offset.y; + _moveComponent.Move(offset); + } + } + } + } +} diff --git a/Runtime/Resources/Icon/deepseek_icon_long.png b/Runtime/Resources/Icon/deepseek_icon_long.png new file mode 100644 index 0000000000000000000000000000000000000000..4305dc872693df8b142aed2abe194c556e733794 GIT binary patch literal 37483 zcmbTd1yr0(5Fj|gJp^~xV1s*bcXwxS9o!uP1PCs{HF$9MKyXcP4X%T`9KYnh-Ftht z@3!B_H#7BBb$L~HPo%P<6eUobzA@d zWX!*wZvYvYcmM#*iM6`6tG0qXpP8dQvx&K*DTvwA-su$@01y!JbTTos1-X)$f-J2a z1SueGT@+;2=7JPjoC-h%CozzfwX`=Fq~@)tZsu)k#%oR?^npyklkXLQJ;>FB%+ub^ z!G+ILkm7H=e6QDkea%8a_BV*DtssTSUj)gt6_m-u9Kj$mZe~^{GawL1#?8xY!o$tZ zYRbz<#s*|#WdZWOKA3<&K6Y+Cb{?{S2gNHnu(<`Fs<`C8#9luMQdqgVI`OfvczAd) zd$2P*f-PBCd3j$Eu(7bQF}*@Cxp+Cans_ofxKRGVAP#ad16w<}T01(B{e{uQ)X~jV zkm7Z!|L|b%^dDLWmw)B-DlryM6DJl{X5e2u{S9bt_8**+8`$n|;^t;7AUlvf$ida+ z6_)isSSKq-S4S5s$Nv}9|NZrkDD;xg`^18z(+7Fv!H!5v=a$X!l1`%73Oz#>UPJB%{-^b})DJaH0Pn zZUBj!xPk;JUbV)_1Y~0Z@~X1}`8YWFI5`=BJbXalKcEVZ=GGQo|4UHbR~`RPpszM# zZsKb4zXdio=3JQEO4lb@H z4rU-3aY2e#o|&z!&G~pa%vm`&LFP+|N$^QqySysP>tByh13CYDWoJ$Hw-xZ2 znEhqlf)r+dsTE{S@$c8x|Hl&e2d#${=oRVzhr0g(b8)nA^)La0L@ZyW^}jVImeolxoDi_iCiKb zMKeRAvj~51f4_G7ee2WW8M%pP*KQ0X3xdVN?*Sx8wn=7a)G6Iu>bi|zJQP^g%c-r* zjC@jeG#s(bC^x{e2ru+QC2b$tX! zE32;F&}%rnBl>69<)-QZBBDd4I#ZWy2{k38FDmEyw>FXrO89vG8KcO|%!$Qf3tuaZ z?%QNx9BbykD(UrfUABZfGB?Si{Tb|=M?fAdVuo3-7zE}g7%>-UK;nj6v6v7ZiRV=a zXN;Dhn!_E@(Pr~I-oNqc`|=?53FKR@CAMyy-=g%Xy|FSW#VWHYyC3*LyF4vhGBZ@a zG+g*QT5F9}*Fi^V;Mnom5>e3e+(*7jS*-AwS*}L~?_VZ}c7U=LZ-w$YHwk4TIWcBM%ngxKOj&7}*yN*)G2-L&s4!n}IJ4Kj$mDjOVT6z%b(KP6on1V8kaxxPJT#YzM{sKv^Q{}{ z@vXQ0R@UsOB{r_YwS%T^A9w9Syr)g|rfb;81xs|Z0kVCG7;nD>v*5*(@$QKHjD&m8Lteogd!RB+-8~-uGe^Gsv?cqSvgLJ z^PM(PK`~8Ee+Ew?vZl$PcmQQt-&MA2_?IxJ2B<0qEH(CAiI4T@V&z(lWoZ&ti(@$- znV@KeGbsk&bsu4U?+~_VBlD6jb2WO8tyH8MDK5ZTdO*OPy>ZSye^GwDvjd98emK$C z>d4H4$5XF|@)EE3nCQbkRHf$%DdWv!1aw=iUGv*!FbBws+>H5h)QxYh@qW9}x@o9t zA5$UtV~acJ7n&w}D-RbqM!7q~%AhCj93dvwYCkAq(=r_1onfr+?<_<-+8$zR4l zy(wmYjt^7fOTrGq?xtZELr}!%Nt%|m?)7H)QY9S<=)f-2VxVpZSof=ADSos_=Zjgj z%sYwCze$E3iWL0fhduI=Mb5$h12c^?w#(n@rSUC`_VbBff67G9pFwiLyysQus3&JO zQyar1SN%e?zZw?B=|~`M3@Bllu-txhsU<|UMzI2*py%Rs+NrAHQWab!&7@f_)%YRy z98Ie#xt(}lNkuQM>Lq+Q{_XA~)%q-y=)>L(!ip*EEKBWaNsK`1eVG|48miF62ve>Jn zXPTF@Gbc>Y(}`}C{R*GTH6JUL-+j-(toLlh--IX8Q*+?`L*oc&>47%@-*ng8P&voR zWpuU1wC^7gd}10{sP_Ai%KRs>F8^*4EC7h&F zbBQiaVG!!^-fUwd;wZ$yP<2V{hf-}Nw6(>J7-7l@`DgUq(Y5sg7he`Fplg_ZHE6lZ zl|8J<547u{r@WogcR(DM$Wz!+wI-+T&9VQef0aS=a6)|S)6&sxfCVdb{h}h#e?B2S zQly6@J0mY#Nc|33;allG5ku3bKapa$zz(TT8iJEk1xJd&ZFucS6HJ(pXra&~<9U z9Dw|z3t$O-X)o~SL%ZXC)EAPgd)ybo#I6{T#wc&zOk^gW*(Ntd-T6o!m7@=MR8%c} z_O{$l`SX4Yd63CXlIp$t%2{ge$A}#VFYU04X|E4&~}=p1BfU{oHr45U)Idl&BHj*S!;tb*;(yaoBo%*YzO<$h^Nwl295Jm{9* z^Jmqp;!-%Aba?DX=^2h{qsEm~41Y_MSw=jVbjec?X_7Wy#OX&D1 zMK9ah)u6*h_rO6oY4A7(p*MgK>s%Et{J!b_^WDCsGz z@TpE*(W`hjA@`)P-+e&QtC-X$&*qn+7tIyVW=XCcPi7f&-#!fk3&hoJdb4ZCjYbsz*(-I>BFVW05{i5gI7WYP$__O9k ze96#Sb+6idi2I<0Yprvmtnjq>153kBSW{%MD?k-R6{8SOZ3zP=Fzt=Dc(BRPr-X`J zd^iqr<8=C2i34G!iO#;d{iS~sRvs3Xx(VL#0*1{;{bxZL>@KZAcVcjmw2HAo^9J$L z*Mr^Q=4|3egitdUqp2Pq*6VmpXPpRW7b@ zo+;oxv~(gKx-2@q!eD>axN zr9eaAMl#@H3{R!DseQ%HO~XLWFx=bw8mLC zD3Gh4Ya}+hz9qFae7>Q56D%x_F3yM*RJ#VxnwCaAPca6Y*JiByT{+kwTw0pF@#^~R zla@*{{U4JMRR)ITk%RBdtV12X=mL3>^QN6Mx&#^E7yuPXIBZk5V#MhiHLF^V%nin8 zx8I%4d`#TJmoTj*6`u0-0LGqHyUA+ikv1g43S?ZCR>|I~fF>W+xk>!AKScY|~rotm1dGi=3wgDhP zPez+|2d0vj*qQn%XN|F{8h#>z{CCwL1Q_B#MSxy`PmyLrtv1`AOpBGE!*uW#;#FJ4 zT>CsnQ&y4;OLi!8LWc|rPW!$;3oVk$}~>b%QB?AbBCZZd@xO5}0b z4g9!(!0w|PUCIbp;3$(vp(iU0{G9YFB@#B2!b+YhDVP}$n3oicJ{@WBug#}%Z*_bV zYJZ5huf?AGK)2xGaT3-MeOTvw)(6sN6ebjp{+*Ow4yfp122Mw#+B4sln5<<_G zy*AVi!M3jI=q*Crb3akq4n;3a9+ELJDu9I*#o0`D0e^t5>YG2|$wFk66(u8MnMoqI zviqDT2_1E)Y9r`)q>R9!K58NEi+8n*%SKg$`+ToPmK_kW$qq;adE zFZZIxN9R@xOBXLWJwj}k2-p=b!QCrt`mv8bawaTaA3Jd zE57T~0S}3u=%LDy{RRJ(_pqGJZ*K2_pL2ESZvd0hsI{ty7}D>H0Morx9N*MGIN4Z! z-65U=k7T~RuA{1{7tYYscP83_;-ltgx~_UJxnven&HQ$*+Do^lsR8eJf*McO8Y{s0 zTifPI#?E1uvE|=h9)XPVS`n)u*u#awnaZqFX{VDZvf>5ez=Xa5!eA&R@Lj{>Fy(lV zz&GkAxN=^bN$E6ueoOKRlhhO-Uh#0uTdFE+v&o6=A%rn+owT3ebX6cx5WjgzDPa63 zcE2l?UG0hw@KC{alSRN0#7SC`k)5q7-Bd^4cvHDCk{BWon+2$@6yZCEGx(T+N9+Zd*cNX0Z}>RhqNC zkTO6 zYV1&9)y)mZwuT`V3D9Bt(y-fKM$!yW(HvjJkga`t;neS9C_#oFP^TzzlOl^3(Gn57 z;|{O)vhb-(=QZQl;yOg3U3Wa?3O~w_t7mqXeLhY_rqCpyZMq>{xifD8rN7li5d3N! zip9Y#W`&eNp7%htjG7>b%(U&Gv1Q*d-!?7Uzgu{2$JjLbPkaTCeeX9@5`xg8hEkA1 zC7F%24XOa49A2Wh$8Mkbkry057vVh{d6W~n7JMR9w9e#osKacu;XeNO4hvfX++4;V z*S(&7&)u2n5t>Q|OM!nEs6g7!QOlW2d^+zyb@XH0~5*Wx$7C4Tg!9$A@*pt|g`PDO1%>+TS{uy;18;<`B8BK@EHKz;QuU0xg zel6Olr!w<=TT{UQEdI5I1=A$^mCbFtx&n$_JaA}02K^CxH>C2V8xq$EY>{cU>PcAQ)D zS6*kK&*;UMUEJy|M=u~6exwXRM1b#eLr4g;qo2Om5$w8aa$YwxnBywvxUVvlIe!g* z&+p;_iSq_mJtZ0qoU8}+Z>5;dYj%cht#hX$QFQ=D*aYT~)g}dm(0cA~Y;ARpg*gc7 z2du2GcYh(p$Rwe6UAhxCrsruC+s#f+DQhmTa$cd_PO*O8JYxPQLX5(XE93bFEh>zk z1cw-4*?tK4c16k_*@WCVgYMAm4@@TTD!Vj69t}(gOvaIZyO-t(HqYIhkc4;Fw^uF4 zEcvH5S_c4fc`|T+jT{`i?IHz^dag_;nCO?ebZonh0d3*b8ED3On8=ErhPhqaP zU6=BbVRO_WrC+q0-F8k%L0bPqzyBQlAr8L-jvrm?!I zs(5u-UXu7f4-`uf-i);>xL2}-+R;)P zQ^U|U9#Y&%JFcD3_Qh}$YoQdvlzl;3E$Y)T2CEkSv)DQcAKOOd26?DaK3yyLEVr!z zAE9OvsC`R7fLrl!ayvPax6riPS%nT(C{e`DB*7<{zxXPV_eE9z<#uQ|Sj-xc+dk7$ z;{Kns$*dU5fYN|k`EDp^EUdKaGb+KaP+0`F0w@c0F$?kTPe@#tP!^)X889geX2_X( zYk5ZqfP@b{242uG!j{fV8L*>K9|wu`b-&RNpIa6}yi{gf#ajCRlwm=M zSmBd2!dAQdx2_x}F~X?JT=N0Bl*`TJZ>+vi0d6k|ng039npp(Y^f7*nQ52h|_vr}8C~ zrWD$vcy*;?)vN*b+}+dF7xv_>#wIiRW4o4y78P^rBL;U9Nrya#* z&$MtVd7YMT7+9BIRPEh1W5xmO@OXzS1ZA=MLW7fb1aHz%4+5Ho6eh5=YU>j5)=p+( zy3dvA+O=hC5(cd-iV@huK7R6s^TIy`^rAztYHB8s#qDR@$$# zcivbumHb9paSFqtEW`>HhoV9VL||qAh%kx}1bQ1JD*h1zpgClzHe@C=>1#XUuCV-j zJ_|?dkunxiIs6V_?1X}TCGU;R04pL;Onz3VY-S`qHI2VbeBhH;<<&DSYq3cjh+{gt zh(#$)hW@Vm6?G`Oid@Dd%ng!){Y2WCSaGsIlC(Ij7`E1!9;|8oi7r9VTPR?Jy+#ISW-gaB5F%rn&*;9S`teUS-^A$cZRV3Rwk>(A+B`WkT<@Z)y z>DJziSwRQ<0mT>D=TRzJK3!kz@*ALQP6vC^&&uo@?fc-`QM0yDu%dygQAK(NZTN3MDu3SrB@L`Ev!#D7nZPEk+`=k@KBa^3mN-x<(1`I$Y-E_SqRJ z?EqS!4w=g+b-06k=}z4+xAW1jYp18OfP_<{ku>)rbGVxRZ}|)1^#JW=Mb{Gf&$3Xx zsKS9V@Ih~Yb;&s9BvazQ4H)rpzqhdBNRau#7XklP5a-LDU#HtPv5R3TU+qol_UnF> zBccYEUG2Pffi}z=w%Q56KHyyrUrJ``<|e~Py<)mzRze&N4SY^9MhqoxR&V#vIL?Ma zYof{gxDDm^?@h_Cv7mqA(2zpNgAcwlID0-k1!!|+NGBqolwqnv;6~Ii7^163~#3`|O zatcfM5|Ge-h~L_DTIEf9`f$^@9KcTnB`;$IsLPp+ z@4H5}czrh1OkstC_U&XO@OBOGYcP^L#R_gIYa+8rJ%dvx@XNszjddOQHa(;=^oxLw zWD^cHTV^bw+0U@k1 zg*mQbyD|1tX`a;{6o_tu-!411;FQlNQh^ zbGS9e#9;4WV8s=Bg@L zS1K{?jLeUjBw;)wA?8tNM~6z;v7~E50ht%V)lWb>xewC*W_)b$95oBiu4)9}bKqoQ z8-+hMZl*b;3gH9<>k2ci0>1M`?8+i+;w0u$%lBInx7XH2{4Ta;DlUL zg8r_xnYvw}1ByBKB+Xbg8Cv%S&nGtz)?iXg_l7M3!VIAW19`DJG&+~P8C8zdm0&;D zmpF-LhdYD3;bH~(RR!7o1~s!m>kBE?!Pv^&pNcUUacGxEPgC+$lXpN;tnj=7mPT$C zeV?5ERXyx_fS3$LZ82BVWvL%y%ttCb0_fmcX9-y{x53GLQhsk&$eX`XxY#EF&Z!}2@C6VhD*qcmx29Cf}UUAy+Xoc6aC(sPHj^XgqZ~!?0B{?;fw_WP@^P= z!goM;t@2w8LmDmOI=V7!w<@yF`0-~?sqrrf`MN|qn6C>%INrYm@n_~?Ogz(A4=uk- z6c~*0r3_vhZ%g^ATaFnb>9X#jpuA2ameQDIbsRac$L^-- z0yXz)PC{N647NuE$Rf>cnCP8=uLoRwus>vfi2HCk=$9Zb-Y^;63MWtV%UTlW86KjR zoWjat$;aioD(*ynStRi;4`T?j2aBPzj|>DebrySgFva9yu2TIQM$!j9d_mtFmicSX zQXeIS_MP&tI*(IH`%fr62BH!h@-RAxgEdmIR~=8v_7?-SNBSpzhe8JBvv!Zc`B6&1 z!=Uql%-U%>KlRP2Hg>wB$M}!#^|xX!S|&Wr7ef69*K6J!)_49wIW_uZf8I-Q2O|*TGGH7U1&7kn4>>O z|FwM$@H#xCoFf|h&gaPNHrFTR?>3gusMlDcu^mFzr}Y7};psdDWt;Q0y6ciZSRXWeNzEa-CuYy!`1rbzqbHmHjcDbm z`D7p-r>Lxx@8)&ql`L<*gA85wz8WsZ@Ax#E7Fn(D2OQhfRbX|#ADzAClcUIL*tR+j zK)B{44Ch&1ZA4?jG9QE|<=xm|)Oszb#IE5RtaDLtw0|lieO;en_1Mz085eWq*uwMa z2Vl0UZU3Nf|K8YtI5=5afux0Y+3D8^fJ`8JojL`}esCX|8mfLrpPvPHRoUkzdwiFR z))f9^n!b~=ji=Mewtqiqab~XJ>1MNbXX;>waNJs9E;v<>-f*(xaLlsHxX7FI=O7V% zQ6_Z+zV7-tFDaI$o&H|iLSZ<`YXe4ola`8j8{J zcBaAOXb~}&s#Anu4@l|0K08I#eYyEG%F$xo=m*FE-2ytSBmsxa#}Ucobx*@!s}`bo z*)eUH8|&MmCm4wrt`xb>2kU6d>rsi{JLt3*m!Zr2QWoWbmAih>f-l(G0P3eEd|42E zav$nhW3Vu)3kfx)v;%LGvgp-pJQVFs2}8zOtG7j9S5i5P$0KV(v5@=B*Z3U!r%CZ@ zX(3Q$Efky8(E}+Xoz}H4aQ)s+@9BH>n`w+cTSP{!mD?Noywt2#QmfI8gyH+NQD>hA zz?(N)e7ILf7$uN|c)+HRu2o{@4G;K;+%G^kjL+bRIr5**28?|<5|7qeEfwfVj?+8p zqQE@VcXYC2sL5!uJ{%9rRiCSQj=lNC)ZWuL0jZS}N}CiwCgGcHsuVGPTngkHI^fUR z06mL+$9-fTZkcbo5DE)g{bI1V6{qm?rC$4ur_Rwa@F!P?+8cc^tV8>YmYbWxu@UH9 zYr{{!-QeI8#o^*U68o)H)0_UYard6cJ{kcAdm@9avp@vKPjx!h3Z9zbgmeD5i9Xfo zZY+~KPr*Ut^&AoYYlQk|hdn2|(brxCxQ1sh3HoP;doQ)?NC3I63M+^40Kdp8aFOh-z z$lkuI+q0cYv;Wu)`|yhoQU>cB#6EmdRr8ltLZVMJS53@i`(*wdj!^mF9N)zi-3^|M zdAvu_j-wyA;^voVv+n2vD=C>Q1Eh5@_)4PYYaHs)qi(n#_h|dh;I_^%O^5KiT|+p; z=;(97u(hPE_oC_Th3I1#<+Tu?d z(KLL(rhd-_v<6+Vjw539lIq`U({#3VOe(}(J9O32oX2KGEpvIK?*{jOmQLW;C)6}=SODKcyH9qynnU3wAaXu-KFA3aU-$*FTWK^@Y zSm;5vIONVQAv1HLLuy9Tqn#F(xi#xLiBX-&O>Upb;YHpH65@}~@R7b$m{TKIBz?vw zH<$c44Gp#bCTR3yU^4nQ3>XHHlIGx@h^;aqZcKQjMlw4q-5Q-SihfR!V%T(*H`W+Q z6m+FMpKQRV(QIy)o9RP+H$|oq5IH51TjF%S`w~%9f0dGXP5XmI^g@}>`*zED2`xfe zp-J1FGoReBMh$E$AYrdNyFI&UF}kC}du)DjnUDH(>27+eJCVD)NtU*nn^6>6gIYD~ zK~veg$Tk&clj|0<@7MIwW)+EzlnAvHTP=9wNG*M}P{^t7gtn%6m`0XydLpY;*B*Cy@X`p3;=W4|KeIn+JpF?gztnMcE!gBwX1^1 zuwhC+CDpvpmA=TOvu;X}a6KX`5%8S5uuwv=*Ts~55f9w4EUFHVan5VBE`Uv=jx@pB z_ZrtCZ8`WdTY*grC!!;&-NC445L}@JTWTnL%{C$vNGoIYCfqs9v?FF?rEvZ$)5l)P zPTQ6Ia^^~1o=>BP{oc3j3U7PURMZG|Lt4tEmOqu)kyTZqAP4k&IYQHdvdajVz)9v@bQ;r+(S zXGjZ73LkYg4#(Xuao@c;sW>8OMw_;o1oS{n_%YjvdOyk+1FH9kHpJC=_(t8)G`f>c1BBL;|4gL8 zwgTGwSzzp5t4bE*Q@&`e~5ipIjW1`wMsanecCW5G5eSdJDPUCh*l7? zB)YM9^)kxw+>BB-4i1NLm6UJjj8z$bS7zZ@_wv0Y6yj}_^S#D4Zz&} zK_xHBZtS7KGDt=uzauMD`L5gWRarR0Do0osXO0W3PQlP#cEiTN)vkPBIkE}fplw_H zGIP_KX4vRm=!xFrp7dJv4R>S3-9!C$CyDwV3R}PA+tv<+oVNNW1N-44FGg%aQYv#a z>cpBMVX+epwZn|H^gX`QpQQE7t#CNOq^fil&iNF*>CZJ&&tj-Sa>GnAGI)nRS36Fd ztx6N)KVsAK7&V8nf*ApPF7B}tIBw)`K67!Zv5OSfV&^0-A)UTMk}dQ)E>SzJ9=UL( zp`(_LMW!;6{VruhOt|mIgipG!{GPqt>KD9X$LPXZHgEHTvk{p#{-iAOM8QH@E_+>8KuskP<_;#NCN**+`Cg}1@XeS}4U@Vi25<;T*Y`Sm&!7l?4c z4fo|;NhAt(Q=3JlPgy0Ht%_&;Rh}aLd76Sn)bM35ee)jmGU8rgF#oz#t7hXDi%^`_| zluQho571YnHAxT;s>?Ec2zGy!H?FrMv-k=UYu#ec$Ggzy?^hOSv0Jc{)5>n*J!JP0mA4bMfr!KRW?-rBS zg3S`dNX>@1qw(s5Eq+QQ8pZyIXwuaz^YQc~6XeAwHmcbPSss+?enNF;`|(^*edDy2(6|KuMmW2D*Io4?;zl439xC|*VuwjjZxLt8rN3y8 z4}-D#PT3%9BATbxEfmv>DOA($J^c<6oAbKjZ3^S)u6}UBH_6T;q{f^k3-}fPxc)nO z3)$hHQ*k!gv%Grk_Kn)FWm{^%P#sd0%iWEl21BL~dJPPN96)&#ip+|tfSKuen^J1c zzk&;V;#$7j8?pgEjqtMKTakG@JeO5Df zD3GkRrJnnq{mwm_e=2DqEQTj;>r6>kbJ>3tBD~eLN)2x5aB1~ivYUFcC;oA7)D?riBuh2J<9FkY=5x)S zI54@4k?}=_JB_0+m?87CMt~7+%ROqG58bY-i=fo%ZB*=Kyy>8xzBWB}K<%<>Qk43U z8>#K{)m^5X@^r3iYE}4)jj7em&T7@#a;gevoVofKWw_(Q=1KRkCCUr+%0@9EoGk@6 zb*};;hFg40-0q<(UkDl6CN;kNv}Ov-e6QW$-X4i_c?O{b638gi3QNV#ElWi0@} z8IL-}5kX3DxON4bm1uB1K?NlZ3^jQVflzJoTVRJ~H2S{HI+$fu1F}<=3+Ny+OkD)H zcU_IZBNZ_M0wu;K3V%yMaHQR~4@#JHn#Hi0zFZupTO7aN5w!?Zd&*gBvt9D|3shL) zg1?f(hD283s7r76Cm@TvGsPLqca&6G`H@lks#6D1I6I~V(k-nv6b~Q$+WreGY!zEk zuwEY9<<|S*iNCHr>3|Rj2tB9ZSDJuL);T(#lP7sw-Aqp_m;T1D+93Jh?Y?|GP4g^X zGCHN7*eLBTVSX8-)6dc(c$G6^paa09jT?A1wk(ku_Uwalj5-Y*KrSUs0?6@=JD4w$`l0*Xz8f zR=0_tjdqM5yL@@At@N*hX5gkT1e;K}5)HL3FZOS%BqN90aF_ya^ukg~^PP{yaJ+E$ z1@7HM+{+Ctg`n$BH8nYQcGjFRD4|(ybMIX6+tL9=#db~(&(lcXhlail zF-OSHFfX#X3;D!zHyIefPfjNLRC$sIOSj{O<2 zN%*a6-M4F78PdYwy`ZxmEf)f*;UTM+^0}W9v;H&c1HtqY>qJnS$v@-wh=@IHUEF43 z8r>}|K}Dt+Lcg*tqvyKHHnrEjkh(<5&t0kkqLD=tSXcNzJu;za%Ps?Rc{PXlq-mvDdY0y#6O8AT}>z<=KkQcm*_|QIdHL!Q+=)ezy-%= zNyPMEpg!?hSBBg?nCH6OtfP8Ob)k8+@i*7V@^C&Gy}&N=>)*n<1m>Hb-e>*jGWdw) z*)NLzCGzYkNAr|JbFQj=+KT`yr)67O@6V*!3FJid2D@8q-q{wo$ z{DI>EqS(m(YpR_@@9`K)O@8w~b#!?t@qpcWm_F>96+(Dbj(Y85Vk+&Ut`IgdqbJmG zjKpD@zGYY1j<4PDYdt1MJK)+pmYA!RnjjdwU&|Vc-{x)0LcJ0oH4S~{C(bdpIEpdQ zeS9$c;jX_@`)JTL)X?So)uCPH%I)~Ek(o`(@&g~?Qcodakg=HJzBuofS?-A}3=8@K zrG)B^!Ui7>DpJbEgxAw)`^c~g)#XN+skZqW(*tfR-7V#OIjG^utYUInon3o#-wAb} zKPo~WauRgv6>JExfA2;O$7>cTsd=FWKHm_;*v(q)p&5|Ab*%fvE35UI-O1c#sBn0CIz?rCRNL<&HAt$Y^fl&nZR(dKjEa&&XU@U zsJS2C^E_8oWz$+qhTm>ML9~EQOuYEu^;;a*PR}bcRORZ-bXbFqfO4d|alXy^{UAR) zG$#R`EOVMpktEzbzY^j} znf>zTG$M%KrMW}|xvyw5?(U2f5^5Zwz;nNsN`VMyr$aBs;4!F`|4kddKoW=5*2Fc$ zZ{wtO=ZkDW3{TEI3ok`GA$I6Z{U{pkT3rcBJshneM6mTjPa^e@Lo(vpSC-774ukid z^vykV10ndhq_ynMW+?k=^qL0GfXWCWIDIB8F{3~oqlCz9bO8qc9`xgKH;nyJkalE4 zI6~hg&~hFh^O4%cbmDZqvukYkabeQWe6HFpYDw3Lm5f91GT!%IhI+<;3FNZTE#|7U8j&*|Yte^O-~%bf5HvWqD%2(68-EoQJ)rqW zu_LEVx#sU?J4Jd_GaNDp2=FdEk%=r;-BBiMrbc!-EPYOnGvb?=PG3CbS<+Xb<#k!$(o$=rqU}3Gtb*C_wrGH#0JegyZ6~wE z7+2V4YItd)86P9^EX$a||54uRS;zNjkN^Ifd)FTwp8eu`>R+oh#^9xEdylED3Hd5N z^Qow%5%Am8{My$3>?OR#{nCO7@1+Ct*vp&F)|#@r)`Yo~(yswhH(TGI^$@Oq(J~u5HvUR$6>6ZH{Cpd~#(Z3+d+6bKG zaw~c0!Nt0w_<#oR-@5kBoRmTMuj4t32F7B9F zXpd`k@E?&>&-)ov`2qD0?UmT<2B?|n4^Q;@SkuJZ*+mQk zG|*&2c`4=G z2P7G`#fQP9ps4g7@m*&X3Jhi?D~bKWx(TP3k>h9MLvC$2E-~xIO{wB{(ym1F4~L{% zOI_%uT-eewRvC_JkPRb!*EW=yX3-H6{F8tyo1Vn#oP3U?QI*}%h*?!#H;G@r;n7a+ z7Mw?>ohBH#;mdVD#536?gy}f5;pZf~dFAdVH}J&?=^)uUe?X}9#*94kGU%B45TSeI zppuZ`>z@14oyqV`Q<~u53*a-;4Wr2H-sx#PDYjOAy3BVUQmBghEHiv>1Mtx=A~WI8 z;~L$$BzvPh(q(w^`=Ln_7ueD7VzJu1@Mb(QWF98ImeE%8xp*TbW-6$Y+h0j}Q8Li9 z)C9-;1dn*1<)OC(YfpF2&yJzGJz>gfLJPOPqq^e6wV-1H+fA5e8rrU0m5JT?k$!|A zpfT-y-h|EF?u+owWMt<3F5#E3rER3GdOUT;l-Khjyd;GDDRN8w#v8*oXsz{;YfZdW z38wGPyr3J|gtxi(S!sV$R`0mkypbuPX`IlH4n#oDm?In=kr*tb4hj5~yp&8)OXqZ0 zn>@Fp+c68TOzyJ1gOWwF zU2Id=tg?@*3)^lROvL)X4FJSABh~yVFo>BVZePIG{8TF2aO;xwpGcXW-_F$y2>^)A z#MrTYkJh!^&@mesM0|4eZM(j1XM2Lj<)(ckm$=#1aGT6Jd zPAUH!=sv(*-Bt*rm2V_G>@m! zwy&)j+o3C)E?NYYNyG=s;&XgDDQX4Xrif??3;!%3_1e}i(X<_!RXG9$wSuU%VFx9XF#l|v|*9up*O4aR4O z$m6S?RRzThiIHQwKBgfxP;NQ05CKB)c_u|xl(Qe)*%%x+_;Zcqcp=&<6aYf;lE z7XxPF3IKL?Zq@ii?^8t=$ObDe{a`{#?J9c;F$rDwZ#?j}Jr^7+{-%$i+uUKu^b+D_ z-*Ewep8jJ^0NaYmVb)u9-D4{ru-JICqjjdL_)I=K3qr_5Jl1tzxbYnwg^)#Ol^!L? zQNYMM4ne`4SFYy^k;=xaI|jO+U)!|s`ZrBwG?ZJOnGjlGyh5rPuI?Z?@}CglKSo(Y zzE41~#&qxMvRivffy?7>WSd2ntjxq#-CYnpahBv#H8nRz`koWD4QsE0u(9I;(8Tyi z!c*c)a(MTD2{44FX==gBJJg}QKhmWYShRS>wVN~|9Wy>h%&D|&JG|=$`l3reIAih( z(-iH{$gs1Au4Lk^x|ZuZ?0u3f2RnZ#mb9J7!GE~(ah(Y&+nw+LoLRE+jx*#uu=|HT zjXbpk2yo^YgTcZbfzS*lIqVNKevF~p`gW9}ptKOyfTFnD>6*18lbW<)*)J|D)_x#E zH2x~UH_o(>P)f@?Yf)_C*mhs2QZi4wI!;%UJ>KV3W!ba2LJ}#s8wjpHPD}N%n#S5B zV2v7jvMZZwMIBEtkZnx$N@>9|(^1Px_kyk7czj|&%H#o%91b^aEcp)LX#Weo+NR5{ zva?ttV$0)SQ?mKyQ0EVYA-s`PDlxQd?FUlX_a4`U9=J4<)<&1Eymr0N?JY7TyEYlR z_salgl;0nyZqBfs*jHvvm|I5%dxvXsSP327{X?Nhc$i6NU}}!wRQ4x%h%|!$D3&Hj z4rl)?0tE69=>|YLSOBD8acW4@^^AgRaj0U!J@)2EB4(|Q*;oo2*Q1yuCwART6-&Ph zvYRUXWRxUz>@II$dBJvy^@-8mhihx<9|U39Jajmu5ZKHlg42ZnPX7r2%m@JhfzQakwEU8rLIeU>ML~V9wXM2- zg(U+INVvRqtw|(|h~f5C!^Xs>yS$C21sgXCv!Pkf${dzwZqZe@a`lZLVhlxDaY!RQ zvb=3Wh>5_I&Cd_w7-6Urn6gWg2ny)UD=v9ggjruk1Q6sgW)Wn#mVs14ar_CPd)ky` z&vl4|?gfc3fFkSyuws?ozWmY;&WS4bO4_Xhq=mY6|4_89%Dtf4vHpF(SQ2RNkQ6w{ z?f8^?bH>WD3?h(bC};*?gwhsT&n+rI8nX*vf-*fpIjNKxbGdk%l0%(<`5MFO8Xh`^ zbTT?n-}26)W;J8h!pz1RThAk_w5^SZlW>b8brQZ05mS(fV`uyX1sRADaK_ISmuw8N z(ytOkU^UuFLiMa%byKrsV?D#urfddkGXNN6UV=&rNJngreX^-%vb`}WN+`mmzS)Z3t8ie zSLIm}83C2|N!s-4PIQ@F4 zldls40G)83VT1tJ-7|&uo(zMGK%mlRr{Wlq@a1ObB2mKhcQYac_u8scO+Y@%0syow zzb%oBzP`~DTGOvii-DVJya>C=L<~^Y@T9pRT;Z&e;b(vqfvu{VCP`pRP&xq>e|B(i z-``djp)Ll&Xk%!$CXs1lK`xkFyH&9_8xL^Gb7Hr#sb`G%M&jwy^7u}K?h6JgZ0+Jn z77=@{POQM0L%E2dsN$m;RrQYyp=T`((@o)|ae>bgv^+iLo+6h|vg;!!#umWt{mKkM z!ieNs2Y$AU_Pla)Q_D5qu-LsYkJDKo_ToVI>-W?&-&9b!1OVuod}TI)&x)a0D)2Ym z`+joKrdK^1wJno_uQfJl!ISr!Be&)Fm!(gLmYTkIC zhVD}^LKeFlq^SOIb?urLJo@;NJa@9Qr`e{%wo zeSjRD@i17OOWW?46D}28#M{9zybbnuFr*!W^l=zk3n1o5@Fv@GM?1LlzkEa-wYQPN z3dk{m0jaT^jz4Rk=bMA<-Yi6b-9!!|kn19XPIiGPGx2yLXv+vw0KGh+Y90-`M{m$5 zzJthKHS*G+Btx2{dBQ2H;xFP>-P7Ub4Fg_^Z;AH3lzWBi)A0KOAYoUL&uzz)VKgF- zIv~Y?EwHjx=qd~da$UnQ-tdTwWpG(j*Q53_50J0W@Tq`=B z3^PNra5qMlzpHSfT{yTxYxbFmo_{6GqO5WeG1>pYp}rRiW|cWM(33oMG02?tc`Twy z`4pt-($imWJxhS)g$;RTy2eE1FUB=Z_7<^IHzF^BCjvER62!_euuTN=x8xNHA_nQq z@DS0AwN!LX%P>^TzLGW_WN4RC*aB<`PYkl@hnVY51T$c7Q8lMvF330-%hbM{j2*f| zL-c!?GjkacAoOh7)9f?JAWE`-Lsdiji=#a+&Pr(zLJQjS*UtwEpD%-9sbQ!Y4M~S~ z{%20|8itt2O$vKypGyI=uoXMNMVJZt`Z^!ekg`?H{cHq74Vz*EFBaUWb^Oa0#5q~n zP9^)GTI_kp>_xgT(ftcP>DPyEor@Kb6*PB4)0JC?`+i*z*CffJ1*eo=KY0tW1h6$3 z8y}bxX);TPa06miMfggMVdRnc!8RfUo7TJBm;P$9wC;81LTC&!gf_EYw6N_CD;IYf zMy`v@*}84aG(P0wQXq243S|4+C$M5tb0+IrFc`GC+hNVP^Jo`W;L`5iBd>1uYO!w+ z=E6<`37o?)AceoRw)vVpoILtK;rctD(weLBL-^)IIza%GO*d+D=b59h_uPnFl~o13 z3Uek9~N4!;{!B7&3dbqp}C?1zqxs~?Odo# zT6NE8JpNrOk!wyaNO;@oo7#V9P42sMwr% z%Zf2qaJ${b+X15E|FdyyuGdW^X0sz(P?!wcqX{8K1UuJUF|p0!XVY?&Z*o0Jh^b3q zcc`(u6LA~`sIsS2oyLx$m_^OP7v8d`U!GoWl8y3owAxL-{4FA#} zsKl`?y`4YK%UT^B>in87*lerfaFJleR_~%qJ}}3wZ;@ebS*|{`YA>?T06#0n|%*{z$TE1O0rW@~`CIQIxco2LmcaxrAE1Z0jb7RAG~q)ml~ixRWs ztz7X4!&M<<*GfYh`BQ;p7oa4{zYb>5iTpMUVWg%1!Ax{#d#(*763Gx_S|7@$`NDZV zU-#}G&KVb@+{nQNkr{TL8wLr($hC&zTv`{ES787EON8&z)$kYdIhP?cPiWbTgT33@ z3nkA9mn5XNp#Tp$3;%87N1vTn3zt%JtZ&zs1SgM{TaL3rf;4a4jmuZv@K?h}pUY_x z;6-VHlxO?kJp!m5fLG3z8;wK0#R*oEc#jk%OI&&k5Hh&SSW-dsC&;lf8hn zS=H0twVTEWuHL87=!Z#6ZY9c$5Uhl~ml+kvj0mI$1kwY7QeD}9n^A(21Xco8BKx~c z6J#2YX;5YaBK`tI`~^^YAp1Tu!AiJ9^zXxwYdY-6Eg%ARb{H5CU@fOAry9i`1(XSr zX^@qemY*QgL}rvIJwTM|%Kpq=GXXOyDAgq>*-4nbjxtTK5=5DilaI}Qmr4Rkf~*86 z)s=l&iRtzQCHELeyslyLoA#vUSni1!=7#a}!0!JNn&!F6&anhp)VL+3E!vln;YS90 zUcG8!X!l=fJpL2nM3FROZd8@0P&uEbxa~{$`|iOHN~-l9^tD zN=@xpPP@gO^Crk8Cczb0^|DUU?-9&s_I36#K+)3x3 zI5s^%$c$)|c-^3h`>G??+pJw8d+k0qK3}N9?)3lw7sehWD3u)#rJ4PVnUU-`k?NZI z?B?{}v!CuZ4P{Nyd+SK3`XM1#fFZ z(^{M3;mjOg*!K_Y{d!H~Wt$kT`q?b@GHfhnBe)*G%LS3}0;DFg(ek3_jtuC#CcLLd z;-6gispK#~AVQLZ_tr1CdXuINKRP~kZ0|sS&ruSrGMU8iic9Vs1%RRcExM-H{6)B? z`6^xaElbIUg-m)G-C~$s+Qj_`t|(}+lKFrpC<=M5d*?)50L8BBYQqfy6sZz!PEhV{ zEM#+er&MB_AhT1le))M1WH2aqOOmA;o&oU8OvjD%Jud(f1Xk5e8`UY|pY+Rk->Wx+ zL_qT7li{YDjxXwm`koWDP486Ttfg+a?>Pb1Ylt*AIMW}FY_#pxB>;eB0?>lzALE5y z8EUvLtzi2(vbgG#06q!M%B-DK?|}iFT%~uU?|DH0s+%?{aQ4!V^*pCDgpUaplS92RJ_xY(wR8lu*%A)9am4L#|eNu+0HqIQ{t_%u9Q>7B7M`t9782Q ztinz2RNzxB<5?xrwHyElskf%DONQ;$p%FPhTe%r2^x!&6ljAR1TIGgZdjbH6z?#YN zH`@ahYdi8f|72OF|6$3=?Ls7%FqmR4urn} z%8Esg{=3_sM`6Tyj+B}Hto2Si?*f8ZuQM&t4jYTzV&e-`H)V2kqq6&Om}Y7ekg*w! zAC$F5TFEzr?z^numd~k$@{H|PHeGer@1yp#1;f+=BCo((K|IJxrXaFv(z%Yy{=u{9 z;M@Q8%#uq#khAO6=`x?r$;!htRn70T0Gu-@ySC}ZL7e4thnqGekhk)y5(HLkzdWx1 zv^i0PGZ3h|jp3@bW!&T0q-dNS)sbsE03dT}0l$}z?)$~l%n-!sqn2gCaQT~kzF>`} zYYC;OP8bF}-ij;yfx34wxi3|$SDs|ur~IZ#&5-QBwz;M4I>4SX9E*;OG$6eVa4*0N zohpWI#do&ofz^3c84qWln;D*+n=IhmyM$GdbB{Mu3*lL(+e{>)UF5CD%-;c#C5=so z_dNONqLsJh)Nj=}3?V0t6L#9O)n_kp^6R=5|C0*A-^5g@>(Vw}ZVe$sbD!te*G z8cQhJS=rn11AX=7zx7S1+%jj`HO-__NeHMOc}msgbF@hWufIBCGV+?}=L=)w$NIdL z)llmEGY*4Q#^N@Y*XILp!6px&QkdO~gx_BovFz+FfH{>M->!QrOCXhf7A$}F=~bEc zO}$R$83{ZD28OzyuM1X2ZVgp6-)TzECT1-!w@L=-p~{*_+U7!MQQI8}O^j@}l=>i8 zJ4;OgC68wTBq99%`n%E>_}V9xiS_urcFg1?1bNqceU*zb#~0*tovO$+9qGjGTXgU8 z{Y-jpwJiXcru+8|>idz&O|vo-o;u*D4qY}#;N;BLoCJjb^4hxA_L2xzChWSm%}Io39qhP-u$fdU zy|)As6_whSjf0-xibwmpw%wMTc;=tiTLR0 z8h&07X?jLhJT}s|bxs6V&Sh#EuI|t<{%3-$SoxDn%wGs*A~D(fkL8x5T*Tw!eS*^4 zW|~MDL=3mBV98<)Kq7k53MF(3!efHftG^ev$%ClJ%7>%}eKm+gh<`Xt`Mt*-IprP!=8VS5vs0f zeRq*Xnt?#kCsp0ICVJ*Xe@=+mv!Q$Uk1pT^GQcXe{T%fi=*)~eLiYt5KUf;cN)JPJ z!=`J+Tw&Gf8$V&8@{jDK?<6Rbka%p_>JMCSab2x#cO)jqd%i_ybrm{4458~ruszqa zPKC179!_)bV+g}k{?F`x`@(ihQdac)WHSgzvQ`-gHmonUOcx98inZOs8opmZ=6vr1 zfQjIT60tY(xu@>wk1rFYvJ;?t1s9EG619! zqrW03n_~=#P^jhJf!-I(a-S5R+$P*|Z~a<{w?av);vd=O&KyBb#wG@~6GgS4mYy$I>9HrFGB)d&kWdJIZm@6bymSGa zi|p-u0k z!v$yMC^VknWl@7BeqeINN6IbBe1Ra%WW4W-u0UnEMJYQ;YeAG)ikU+pi4^-Ti!`sg zC&ReE6tYb-*7tIIxbd<_OJ&y8DgJL3Jbz~=xLQK@WvJ$BR%~BP4=yihEe|XDRtqR_ zm#%9u%SuNTTl+Olz)~F0bZt_qOn1gI;cpQy0MhZ-1;cwaU@QYv43GnWN)Q7CV=+jJkZ?t$%tYN}Z6*JT98-Dc zrnJ&@HqSC>4xdl(w>pF7nXSOIdhhcvQaaIVVw@G+f?HtP>k>T(^$<)DK&AX)J zHG$OR8@i>m#UwPJJfQ(9Elh_c1#N1``6ap^p7&Ml{$i-f=NAGVn@!UE{i^B)cx?z^OuEVB*OGd$+uQ;fnWN z^g9dypp!Xlv0+Qu7qAkk@i!Y?mFs4mo7)Zt-}-@X<(l`rXu*HEouWTy!t6%>yVJ0r z8qSKoz1&-|{ArVo1%R-X!c}l;V7UL)71d2QmgKq|>)le<(sJ#qrZN_Sl>(p$%H(X? zd2Om_f&{U}3c4n&BSK7k+LR4>rO0z(V6%z(Z`rL%E69qbClCLD;a^s=#gC!&wo6s{ zO~u|d*}`fpK{9#V#f*g)5C(&Eg0cjs4*2xpD`Ik??ZrrD^6eIPVAX!RyIllj>SFMB zP1R7+MPMrWc6+dD#S^AbXIQ1+%VIrgQ&hCF;JW zSa@??uM@0PI=cV&T%oof**)j1U$n=SdWhJ{W2^5>7(~#kKU0XdE(XF4@90QG4{oNj z1R-9eobx&mluE>oe%4VIPCzR0lHFq!bYG}y`D3F;UtC^HnE>EO=TBSO*4+FJ3%)#+ zg)E%onR@8beHzB^BdCe=zhql=4UheauD(WcZ|{IzsB#dH0z(_8ozYeOE2kLN4Fp|M1ZG*Sh!oxTrB6U7bH$ zXkg@FOEzv->|X~6BO6;G46qSmHmaG8YKG=zOl7Dc0&`~np~JZ)`D0ik0MCh%lV@YJ z|BVN9j&AW+u6oIoXU&Rq)~A7>l#a}?=y>mAx%OG1AN5%jx;Mk_l}dQR65f>x-W3Y& z1_jST3IA=1{kJe&VTNWfgdyPyTNM6+3qyIiIpoVw|F#xDcym3ESt^&o9l4y-*SF_M zLyJF>OHvXhceruEHE)g|`^`1E%9txw{J`c&>rLHpRr7zP7HqTN3QIP^3f@-9o>s+1 zh@rU|LStx#g6^}}bFG42k#C;~ZtlR0E-}p0*NmaLO;z=`IwpSH-}OvU$JXwBKdsZ` zzyl^VJYm7pda_c(AX2RR7_NFISG8olnxPpM3$J8}q2U4Bb49s1bnrKiu^f3skX<*^ z6EHN7FSO+U4j+ASquq1PsxVAuB2hz2KU=7bJ*LtZxX^dOrz|WK?qJ(9I#PQuN2)%T zmvie)9xd@*BY0^+QUPBm3=JNBRy#7 zt+fQ=PuTZ=B`|45nk(*Jxb*738tvbbQ?Wg}Ob)(&^U{?!ZM9JS7YuO@*PH43FDL52 zFhjUp{A}%lcje^jK;StWFQ&GP_s$@@Vb={gL)6v(9=D(jw9^9<^TK_G>M%F8V?HU@%=~b6fe{ z?K0B;=EDsw*X)v_>i5pQ2rMq1$}1CuR8GO4%pi%14{MY&EZ{E}GmTU`|La{1Lms%_l>|X+r#o6zcMF0iKAC`-pI!vE$qYJDGI1 zJGA2G6N9_ImQUZgz&vm-sOD?=q-GYv-0u#o%Q=k7?O)w(7@247EfG(62qpb-ENbk$-x%PW5QsW)VH5z}+?Q8u8NIx;Qo~3BS*&vdm;ihXlW+Q{l3_dvJMtRO& zPJf3%l*;%&)6#n7H++1wJ=*dw=vQDl{UG^OXVGgBU3ya=)qr25|_sb$tafEOZ$ zI#9=Y>uyWwIa-gHT_U|lVC2Io73r9b41;}J>zX2$enxTSr&Yl+A~CzD|J|89%G;Cd zxf6QhcbW5%g_+n&65`K}k9I$vN)10z7r7~?1?q6$R$oO$dCI^ z1XeB@`-e1F&ngHxIlf)52(SKSM*247dM-gp0dq*>=p#DCzLLP=yn`6s#?g>eflnzF z`kZ1tFE<5^G6Rxbjk%s@PQKxD1uh-3>wBDQ419gN`V+N8(JjU1!DKpZYPYVZkK2g1L^{qQhn*qLOgV;(B^}lg| zX+zFR?oiK`P^hBeYQL}MeZm#mkdemnJd`FTQkKB*eUkH2ET-v3RX%Hkc~7tooO{fBTH!*{J)3xZTX{? zWgkATq4AswLtppPqG`d^Pk<|Oz7fuil8MRPSNH;}I||q4g$<#9Go$|Bi(TYuKA~Z9 zheY6ta?3H75ggyG$lsRxnap6B(KXo*mE4wyk34Icu~(9b@qu_EmM}Bfm{Ss3H2_GZ zP*qi5sg&=oaBV}YX6P|Z^R_AFz5X-{DQC?avsn}6uP}@pd$ql${<3Eou4?2LaIJ{g zR0@V5mV(S)LV8<#a_|Wtvr{PrGn4V@hTBIZ0-A6&g4|bmyjAN#Muee<8A3mob=D39 znRfB$7t#d^F4cJO0ZBDqnBCZ-B$130$zG+>`-Nt`8XX_*b-Bfx=}dCOWoT*3VmGta zrs?iRpSPk-)7%l$qIH5?5ye`7YzCvB6_%!%*tg#Bw{_%tsug=(H-c*>ilH#1CtueC z!A1XUad0yr+yGldoCW~JTA)A%pwoh$rKxFS_wCvF;@6k8-I@0`lvf+MHzlk7DW4sV zX#}aXvZAk~)BS%In;d+rrtZeP6Qdp2{qx31OWU6YLUo%M?q!O#VE)gMl7<-hGgH;( zwNM`H-_}y!botZF-WBF_4 zH+p=bh~Wyf0q*OV^lCtJGm`;83$<)Z-n&VrTxWG7FDcqzR;>SB|HVl)MqAyNIt7+=|`27I+RHzkxEXEWYV$zs`?v`-^XLU zziLqsVNDYwZjU}83@xEpZ}bNm?jlj~aj9GjX0K#13(6cD9(eQp)%EN1UaTeK`|kAn z7k*X2RiEGU!hHI9*#$EgP%`U_E(8ODvN270K9kG@R(#rXts&7lH2lVz>Y8f{mMp|A zqK~Cj;KS#0S+h^plMAFwOcmy1W)O6LVaBM_QOZEQ_18ir| zVnwR^Ru&8Ln#ayZeE7}(SrK0L$E>-7rlP47>w<)uQW!{5)+nfvA_8=+FV{<}M z?*7gf7D^Jwe$};a+kacQ;lW=9O#9;=&nPoJXcu5|un$3+ z28Mn&gZ$H4x@qKr3|Bo^u6T<4P*M|NdGJCwT*4}5xLhXb}cSk zLA`TTlg__EoTfbpvZ9Lf&+=l$-fl61_S33ntmpQrTW>;X@PiL#J+k;uB z#Ov|sp*!5c!rUJ^kN;Rw#cwgFKs(#4vf~FUWEILpHey{1Wm5-}4rCQ$0E&qvn6zvf z(84Sd31-y5*yre0d|RmFlid)-f5KY~&&8u@gZ^V?xL7Zd%z3f0tK z`j{nxx0dFfFBD37w8VG2yMBFlZOf*-Tq_gNjuu~N%|Y0nQOooRZT%T4QP4NLd*o zy=QXb(8mg;EC9ej@6Nv#NbWeJ@@6oplZmg|nygq6s`#zd z6tfUS+SDF|r2vz4Wq2D`EnWVO51*_389!uy->xrfBJolo2S2Iw#;VHZ4-~4si-9=T zKklaSe<-&c<$;-Cj>n_DkJL6^(@}0|<_qEGO)8_R?$>za3sj&K$z^AjONZ*n_1)3& zuD{eU@g$K<7b~MP&999ZyFyr_qrf7(VvKduobRNY1~i+oMH4tZ{Phne)x`ZpYlYPDCoh za`?Ww=4)nU>8CtCktpKOuz2m=BZGare&TbhZcQq~O}Y@I!Bi$#q?Bez2#tirV95*? zOwd3~ti{u5;R)1l9PIjkt!I^crp~JyuOB2e`e&yNezW_uq`6JYd#_9DadsJUps(l6 zhjfx9Evr5k5F}#;#lGBk^sOJ2TbB8Vne2Pmz~l?_VR3vu7^H(KINNsIp-WyK=+@9&*B7-~?6JPx|Kj3_@7b@-P)vrsee+GWi}2-wE3~HDMI(2K9MkX4B?w@_@s8Nofj_TqxS^nPXJym% zgM$OR?o%rIB4EaV^Q9LpFB;MV1ARMgt!TKeDEG=Vlibu{(9kV9l6y`aO9&_2Sjz_y zm`Em=lLN_k_ZK8ZW?i+NU`-G>hj~|2(XMa!PjA=OHi|_HJBUx2SZDdA6BN4|Bv*fT zsDEowD~Dc4R7W;Mg&g^Nk@W|i*NZ>U8Xr(Nkbd|x`ey2rl~Z$^GPi1PEPLMpdj3?Pwn7+@>yKaAsJKuWh|LRt3pKfKKWJ(G{rb*M0G%d|Eq>=`PjA=0-<6zrx{x0TAV}rCys>f3{~GRp zeopv*%?J8=-};JMM86?&tT;Je(S(dnj2$UxfY!xG^@2@_xU70eI<8urlLa(o969mCn_=Ur?EA8gH@&``)^TIMJnv%m82}vPFo>tBh-$8BwXO z^(o|+4Qf_>2QKLt>U;Gv4VjUtE8*H36r=G`w>I{EL8-3O#}7LGqogrktWkO(6+iGhrmQTv>z*E1JJ{E~ zY%OV;s;D^I8YL68-7(fAkox?X?C9k{Gu3M6NBp&VWIi|_uqcmuD%*pEacQTazrk<0&Oxc50nX|O>}%cewk*Q=k>IrjMc2`{E4@s zt>_lki-im|Ka)-#SmSn0{3(zr>O?vX5!j%_uiV{E|J)goY=W0&Ebct zo8MWoYn7IbFZUeYc7scde~Dn8v>+{Af(QawgBjJVfiIbpyCNR{^0LjHwJjS5O{%<0 zQ$6bqvPMeLXLc9*^yECuE)jpyjsDdc)I3z^7!D>qJe}psrj(?h=TRdmcLFWH{lm%V z&QBOZ#!0#~X&TUl4nqekQ*kPlVx=s0xw82MBmu&s8|)GWToqMhEPr(T$hT^y+tXIA z|7%+vdxHz(8U{NRf(5RjKti$69tu`18ydyFC@(`wN%bcO{dkJdySge0=>{kW_|B8kqcPfA{Mj zH-eWQuC7~k{Q35WnmY;nKkQ~-BUn*ElV6tz72G|-7g}UW4j!C1_WBD!zdt}ik1)tH z)pL<1dnF0xn1=Kb1LUOnVBr2mL1F!sB!0+jI>zY?76`V@W zs1>O2*jXX4B4s93s{hM}_PzKAwaxD=iVwZY42Cs#?LGDrdN6C0cv5lT%^45P9PM|z zef0pfP}VRfD4Q35>ID##MX<&NnS%s#T)-OF$m$m={z^K2?D>h&u5Txzhd-@{+J4~; zEhx!?YbF!|Zw~do`cg7JcCaGk?PfwP06`~GEu*xSbR~(clqOWvpmb+4cJzx!4*uqE zYMO62Tsj#}5UgArmF#_XxbL;sLcw4KLvKNWYqFdPD<1&arM9?7> zU|FmnKuiS5q?sA9q^7Q+`X`Tn>Ss$<-g*8y3}=I2#?M;#X!akA4T}B5d$KBn&{c$t8Bhu+-}}(LT1FJjog-&jRmccc`n>ITnDOp z&}855C>Yg+Nbe{Jl37|{mYT?PrY8p;867_SMD4;&CE4wn4Jz@L&*QCmx26T}NSjzk zns=eJUETD2Fca9)$n1rReLs`v`?Bz_Df(`L72CPo2)6CCpEq7forXSYnrFRbxi&Ew;o{`tXP$aV z0-Hps?L-rQnM#gsH{6%bSywepb>FNRwGWxn)jpf**(YGmR^O5)*c@}a%tw_u{ACl1 z=fw`(VDHwt1ubpYS<16n!h0>Chqxd{2xbBlAv2^=^r2X^``5D{auR+e}1C=5m@G{`n35iuP{_Ps8GLhDn3PZbMU2vQV6@r6~zu0+dh?3?dfL z6xe0N%*JVR`^@R(F~O`Xy^~;Vo^7*=xvwmeh&#PBxR;^BHI7F zKh$2<;JcCTXGFuo_5Wh2;2##Q;8M9^CQ2VkP3~Fi_P5XZMbw4Ff!$BkEn2jCsZ^d% z_AsN?hiEnk;_xDo`iQ9 zL-R5q09MRaR0x=W=3|Bqka6nR$V!k(3buNQGCNqMJ7dw&-m%f4STa8R;^NhJ443k= z6oQfNXLYyBrE2P0A|}HBPmy;$F|u}MCT*%_j}AbAAwXGMl(prf$Z?-tw$rZj? zWh)sA4X3)K@pRA=L79S7RLabl5ateDQ`?m?do$_yKr}X<7#;0Dv}oCH&x<+Y;Lab0 zLRAYlSBE3(U7lbYLkkN*Nu?AR4|a`@^&MC;4-hFrO&Bjui$=?5E_!it>@V4{B zh3{*a;~_FCS)qm$pHLx4C5Sn}B*y_YX_UY^JlDv? zb_jq3k?;WoL4YOAggbP_oZUew24lTjbblb|64Nf%#3>Lg#WLjzUNPs!QcAt8GkhBb z2t*=41`RL+3^go>lf>|vX7(#2VIE@FC1v?OhkL#*2%cad=uMfaxCto?Qd*GN)2M_> zvq&CcQc6L00i+9NOE-`S)ND2ZnyK6v6`($gM)*EgM)*^+#zolmV}CQXqfn$qU9_X{uR}Am;75%+RhP| zOLW>vVafnW@;1~));*Sv?b}=m*`|rh`e$4s{w*q4?(b5fOqWQ$*n8xSzb&^U4h{|u z4h{|u4yQ6JpZETO&VMJUqWEGlNU*5_Qn6jPBK>zOl2~Llfs=q>^3pLVxbjRH_&DZZMw=5104h{|u4h{~dGAo6l zrs2kfpxF0|R~eOr#h%v21y}rQX6!dbNabpeV*^JgNmzT3Q?ViKf>KV{?7;4UV$l;NVb75~pWwa&T~Pa5y`& zUc^eSyh{_Kp9fUY{LUro)xN5gKQkwHwiK(6^HI~VL6P8|e2SYY)^6iOFMmWP_AC=B)=7|NwjftYOVXc>vtBqIiPsf-7S%MYFIhff2L}fS0AQE{Agk<& zH5?oq9OeTBv3g4te#p?%FBZ#^%^V4ojtpMy#bdDX!8x$3@K{(B=((K1;8?Mwad2>On9CGAbI-`Y?oSC$4iviGvmx2Nu)2QD_pJDvCEF$z z*6`oksmWjm29ZTocQ0Ig&131<+eHcJZdray$3V~ajXK9Wi_w0rFrd{pEq<`vayU3R zIOGa}qcb1n;NakJ;Zbmfp{ntk?!n$)uh6(SRiICWNQtW3T!BlvH6D9xu;*9p#qKeq z)jy=E(Qg#0JqC%i^xx(QUV22RWdG6qPq!DU?P-rOKmbPnt^2vJ?L=#JFn zuJ&?E;^5$LF{6eFDs$?4%qL!_LI6bBBf=aU9309+QECI!G~W~*>VNZ(bfmfns_2!6 z73(2MRUc_uu>J`%-q~L4{*Ddpc@PEuTns=7Z$s;n>z)|vf2F;UZ3954?wY~jW4k_V zP`az!br~40dY^ys6D~1)uS@i_XA*Cgt;U9fgTuuMfs+J2$2fkrRMc!aE=dj!4i_s$ zD<)RmwEpq_o|i7sDfT@;mZUh2rQEG9|H>Ug#a=7MqI;Tf{k4N289(t(K^EWy0802< z!;R~Iot)USxd3gRLUrRi_U+&E+zkeeeTk46DVO5FAX4OQ&8YBKGOFn{mv2?SCQ`dy z+Q_}B=$mD!wc+64aB)FUX@+p0_AZ^XZVkyviOiuAi00tn;4tSXYW3mT=65Fgj_$b6 zz{EEN$#gOMnub9_iQu~GhIKEbCl3^S(S5w1BCfR+G`GKE>DLSzD0u4C))nvR-ud=( zU+}sn|45KITIlw3g9IQnzz9j@Y0Jo}ulOrhzUb9Q?@dkYaMBk#I5-pyh8zW8Gaii@ zBnL@Tj>6#J;BZkwx8GBAk0Ahni=scyaOk#@baot8%&EcA;e(HcYggZ2s8%!a4xcx; zW=JYgR96}TOXBFSh6g+EuCBkj;OS9y^xiC~@u$qfD0JJigbB<7=9q@$OOw&wFSM`FaF|b&Oko)5 zd7-5)a^;JXe61zv@D!MJihd^^>$=Y!SUaoy|6_ey^!mu^Ph>d!Pg(1D@zIbPFcXK? z3*V}O7dlH$cK_HHh}_B`{hV9zWkx`nE{cA6GJ538da&K8-{9cjP!N37v)qF351CYy ziF*M6j1aLFA!rdmgqY1UhWG&Z+ww%FCCpm|HVz$TTB{{P#% zyVy9cDh}ZPb7yAP`{7;3Nq6nqNt}|Tq=ZmNX{COK3Q-WKO(LLD5UPX>z6eywb~UY_gkw$;H0+<3=ki`3^KUIPDnvermcjn>b2 zQhKITJn?LyaCl((nvGXJ6N89|h^WOp|J3Zd60T}s0D#j&|M)_F*^N(x62DIEg$-v{ zh2q?uzG%JZnDL)fDr39r)ybi1b^QI#t_>f0f;2k(nn|UWtjnZ(w_2p`wQ$>`dJ-?{ zmt*GCrkZxod1yFuVn?pK_lEoHHv723YuHnZ1U57XOVG+5zcRY5FtqQbrPtrf;6Ow~ zM0AN7J}^u(QhLK`YJDUZ{}3DE+#oh1@C9Mf+7N(N#W-yWC#fn4z%;~`9Ruq_tA%R$ z^ozrVeNQZ1{lz)!Z5SKg;V#avebS=iK}Ey$HGG61^kX=^wT9fbsB0l2A|h%QvkeUM zdP>s83>WrpailsJ)%8DM9Ki7a$Fu4rLydK*B)U|ReOBXLs%~cL@6m?^0I)Egm1JKm z)$`Db)wlmK7<+Thjv?*H-x(Y}u;UR&N4FXY8h)aw!tnyl{w!^d^C(s#A|j%B5?Nrl z=Gxl^LTy{&$l0godI(x;FeX5Hy_;QkBqrrI>XYw2`tHFOuK31z#hQ)9K=Rw_WBWhr z>EsNPp`#u8b|EXVP9Lf7MqLLH5fRZs6X-T|J0!J!Bl8PL*0}%G;zGT zCfCQ(eLr8dX2W0OX5@idaZm0_zt+vJ8#pyuI3mys{u_<4(sDj)dCDOX5fRaRiL8g= zLc!!)xkP&TuLESaC?xVA)64|cLapzb@O{|I+kS20pXKt|H_D~62g>E~@i44UuDIc= z7ro0K*#A-l%IKA|fJc22IoSJd@(^>&eAk zYk%cy=E14H0h$W}wSur}Bpea=gFtv(BrK>6iy}@22n&JM4jIQxs^}?&(+4Cr+Mw<0 zK&C?fhl5br2B|5jBt51_pPY>bNYK{2gUq@o?M> zzf!l?JlhN>^)v&87=@d(>h=NgzH=`EP=%@r)K}P=LeGRYtU!@4i1*;!FgHP1b1?SA z`zHqa$Hqqv_w+1}XS3Hm6=>=ng%in44M5ePa%kwifB!zW^sZ=1AR;0nY5@(k!f-yn z^v>p3viG-;w!AjrzWIenp(=nvaPFsCN5V0qXSVvtZ$JON#}55H*VVJ;emLpP@wWCp zh|?}&JXMJ+j4KeCqpf8sP$+C52#cNx2d%9atgRn7J$kf%QU2zgb8rnJA|j%e(bQX# zW)j25_XBi3Zs9iUFtG-sB06=HkwPxNNm)`uigPYZn5o|)mO;#`_D$|8-BGD~eH< zLqtSGM2)9u0|NjoU-OkAFS+z#l~^|A4S&qV#A{G{krfA3wET*MsvsykQrcaec=sVi z_P%R-xT-)zL_|b0YwEyozLJ0K(8!71U-mHi0~fWE0<|A~mk59sZIo6u5)|X6^fyn3 zH;o*Bb4y!#)%O4YIU*t=B5Gw#b4t=|RVLnE+TPy#<3Katg18Y)BW?glI~mgMqLsS5fKs1Y_=yDT@8&_(Hu#%uNw-``EXc0dbbJ3UNf*Q*5eS?#FTa$ zbL!hCPwc+4=67ymSRf)IBBI$^uz_KklUTLWIvt-IJlLPCjsNGim=yaR35pl*b!Y}U zWBmfZXynY(E{0aAP2FU}-1dC;?1rxq5fKp)O>6i`&vRwj$2SH5b`I=+Zd0y%<+?;F z{~gzB-=Oev3OAz=w|NG^sTENluuwIgKvlIq<~fyTjvw3KpYOeGr$uMfMG_Ga5zzv$ zV0#!Y)!~EBncm)&OFFXo8w20lXpz_i6U#uHxK)@&3K0TTzy<>Kjj_ehpLivxpWNys zJ~0w?ZA3&wM6I9^dkp4V%Lj%F)z0opy0P@?cw6>Uj+eTn9>%@|iFYfU2pXrYHLz79 z{(BnM-Vv=Is8l8jrP3s7wNfF!?AE_r{hEk~h=^KOD+Y#^*^+dr;)`xB1K1k?djpH@ z5McD=&eiG6vd3bvC7T_$EjhmxsD@z>hGAuVa^mERe)ZJT<nNReF7*LmO(!I>gS zsXe7t3)kmc9-|=VTYw@{gWmS-jg{Vcew1vN%Pe|4S$y`Nf#q9(B2$A(&#eC?nDa)B z6i-TX{-e#*eM7!wG73c{ERuD!Nb@q1%05pZnE?<96o0o zD<+FgQ7k0@lA8+wWff)Z{rv-GuBB3`M9QqCld+le*YxIF)}ff~H9zJcJBPkTXmWY| z4R>e)UdWeRMxm&L24*0%mD!yYezV!tAS?DuXU z)I`9f$YCZz8{_0P#Le9wYPz@Fw_rXH;@R(UVYw+EG8qjlT1SmTu=PdPjJivfrZw~3 zvShzJ&Cw0WBm_hN1Ogg*IRO9yoPBc>Aqh=^`Ds&IHg|isopSs z8?mySdKm$c2?85K2E+9>_b}PEgcBeD(b*3SB2>J-SxZ#`+w&!#5hyBQj_C=$J{u+b zM?F_{fZ5tn4m09Gm_SU!Wsr0YP>k323eJ*a9T{ZYK5sg$t z#ss+^?+mvRFZuWFU}A z7|L!yWT&B2SUp|Gb(C-lN#(8)8LiY5s%1e%{Jot7Kn(q1By{8t)3dKEv(1Hm~Q`d@*U2 zFdcr2mAgHbRGMlSGt~i@E)|3|0Fob3auG-#L9C33xlS)gh@>G<9FUR-yazySW=H{m z^bUsnT`p4X$z&{S>H4cYrwJFN4sKOGzM*03el!fH6uS zg37s;l$f?>&`il(0CF9mTrLE&0-%&l<$F&wO_j0tJ`Ji26^oe|IJnkUGW(YVOd8Ae z2t*Ra-g)=Pw%e!8e*fWY%V#7C?o8OzzOB|*U4LEetZTlGvUR#3$(jO0AQ&0{lhMX+ z=oShk0+0Ye0R#{Pwm}Dh2{=LBu#XXCI`P;g1R|4^e6D%_n@`Vd_;60<94ltC)is`n z5CI}b`{IjcFa4)b`_{YN)hoi;l+Q>QUJ1L}Uy>!MWOb#dZj}JrO;t5lmZt?eKw=1# zqq}`vjDcHzs0L4c@|<2H}K5t7k8cgyw#lTr~~@=04) zSLFTXvWqtX7+4AWJGa@~m33G9YOeUE#?4m>kWB=DJnuF?Bf-OF*FwW7AOL`(n4Ow7 zfhQ8m3Mc2s%=Wq(MQXb%$!jLX*0iVX<=Sfh+*?qxuZpUktE^=;E)(=Vl!Wqc8178i z6ME|gk9YRn9PFzIBx~k=v&oBu(XE^uEAuVKXeb!nqLO39#77{3AXJ9wcah?oqv7`7 zT3nYj=_Ow->F<1_)?L-OgM-C8^mPV2)z|)t%`jOMeVwnlWa_xL!qfPa1|_QrWLr@I zF9dJPw*=>chAaUE(e+?Y`_?g7Ta86Y`K+Iut$+Xk1k7Z& zyJzKH344QYuT>zjrM&X8R*qHwmryCVFFAj(ntV%eF7%F;<3e%?=KiYJf5qDpZ@;&< zeS4$MQ)C4NdLLo3`$Ok=n-F;@Z%Wt`*kY4K=lyQqqF<=sTtR4ZWy6s@xna%=Uo&|i zU`!=z1IgZhbNd!OmyWeO*m~$0!`d~>taGgfrFWjoN{k>>AQ8{G5*|PF6iddAuC1uP z{B6!Eze6A?xt3wFK*ZenmLVSqVrD|C*KD8u)wvFtM~_k3mmOTaDW_@w>a7Sv@IQJdBo$twu?jQ zColALC^9w#C}nQ%#ox=f9HW7x1#&f4nwuMC?0Y0v^PNq9aC@yno%dHyyLx|`s{T`u zrH<&r3k;n)d}aM9I?%qYwr=+I&kM=fP;~L>4KkA4Ux^JI3fNt93>CHpz;mXAfRdz9 z>E9{P6IQ|fjciTR)BX|zfet3g7MG*c>~NOX3NS6H^etSgfpr1#@h&cu0LXIeXiwV~ zm&bqQAq_{GXN%|uf*S4&Zm+HMEjLVriB;}io6yRC1;BE4B|B%r?zSzi3h!mRHFT}W#`r}>BEYqx+`II+8gG5% z#KFz3e9IG$4YV*+Ph@=}gdwLK#yD0zG0^(jvh#hUEAS%g?bvxMqk%0c&37EI{F55D zE&(vRPi1}Nz*R<+NcO)8kOjj`Z(xhf>u>z2V75BF$1ZXKP?8i|&EL(KbKOh5p;z)6 z^gxt&7a+BBcuH6n<^h5;a}baUvb(xw?&@=0A3XWjDu3;gbrqh48wHlEfH9_8=?$V5 z>F*1^4WP3U_O@+tdHsuj!?EP!dX8IUJRk~mEOC3U493C-*XB!#O8@m5KzavcxzrTW zkcx8%2!NoXZG;krPX5IuQ}=_lbyvTsijsdATe9(3ATjvQxIROQoP2zs_vDKJIx1mr z+ZLCvX354hxK@ufk+X;{jCzw3C@yDd{f`w0-kNKHPQy^!nU8r@lBf4|zBzm7YyRm= zpV83$HBFf7biO|k#<_h(AOSq`>p2(yjR4S53BCTs8&lv~jf2VSc`md!r8v7HfS|!A zGYKKNRPa41L%O>!ko%JJvDiR&_Gck6V#|w?QsJ3#BLF~m*S`A&4Q%1$ykM=HiGick ze!UPR`g+@%&Ww<$i=wA}i|nml@I8&nzDmd#3~tj2u-NA!9}toN0D*+VEZ;Jud(_y` zWoVz5v;4e{w!hlEHOsq5x2@l3(5VWoLluDtQR@ZZ5dy^rB$=}}|M)>l_7GamgxY1K zD8~}&-D0MNkXmTVVo*P{Dsb0v$X=K44z^;F@e zY#C^fja-Qki4-@HrOs#y2ml~KdhgKxpRlqVKk%enKj*3kIN26ME(#hI$ryoVx5Zii ziVSV%HR0=tNsd1RB#OaOr$7)q8V&x}(AOrcJpP)CR|_mzTTHwyEHpCL3Gn`fiN0t0 zLff;xDhApP{7zdU;# z$6J$WT$nMiEJfAZrn({`5>JHp&$Bq^4?CAnXeE@X<6dI+Ir@lJBwui_*10{4{?gm= zYE~WlDe`Y;q$RRBMV-c`hTqO=Mh$8M zn{Z0Iu80)s|G{YQj9Za3@H|z_2P`zsckd&r-1!Md$-1eT0MiYx)UR#As+>^2nGvo(}KHiq$kh{_PUQUYlCGQX-kc zf0P{O?v^!XB~+}{pPTB|t;r9fM&>$ON&WNLnxU(!`7VaZmTZl0BnX6H7=1Yu*!$J< zT{k8rltte&fKo9idy1e5^Bf7aSSoz@UcJXItGeQ_44v09;3>VwHX5?TPsYPXK3Gw6 z&3QuwFQ|m6@UaIuD?L~7(jt=)WQ>z+v$*OXPKS5vzBNtL^i~BUzd{hk>cOBJBp7O8 zp?2J7aW1}K)wv5Qq183*-kkK=D`GeZkXc;wkEoHuy5}XfwY>ceMfClgff|NMri=($ zQikqN5v$oWmg~=}T#4B3Dgm-pAJK{wA_63{*;)5vHMYA-&v7fKuL^gz?|pzlY%^mb zhT~3*H71B8BueZEp4_*2te-ir5;|P|+Wh9|4NPY@f4RjUCZ7LAbPLMQ3-{ zi5E3B6-VUJ@n@(T5TU69-EDty*RC3~-kehj6S4h`T)6%Pu$U!Z1epMf*J7WsF*UHa zQO}V}D;I8v^c}fdg2>|x)IL4O&Mia|rbGQ*M}B3moVRW~pFF1$I!o%l4PN##nMdPN9lRLl2MBhU=ta@4@KqR3SHev4%j~#sR@{+1~Ul{KQ zqbgWD{Ekc0EH`B?V3Em&MkcSlWaeXu`2N`!zIyDG*RIl9j_rI5sqYCykvikhrxBig zgLwLh7;147#$HZEj(;jm?r+r1`M`u~zK*Jdr6tqu0bqt~G*TpQoVocqw=8lwr~g|# z+@!1fqNe@>odU}4h(-5KlQ6OwfJQ07t8<1vo%%Dr4-sQL0@S}gO^%haqkc?Q&~q_D z2~Qk&u3i()uN0$Wik!uJ_X9Gfa{Gr}rS<=vjyCCPH3a~$*%x+phW30`g2>A-BJfq` z;}M?vGv>>+xXi+jhXT95C7?o=z852YAb;)L&j>V?k9Kj9BJY8y3Hu6*^OEC#)=@xW_Q;8 zC>`Ic`-DH^yS{r&ZR2W>E7#Ogc1_UQ?mPO zk%=QnDYw|>9#Lb*@7I6y)DHc}JU56yNLs=o$A4pj;8Fo*p9Up2mwOkjFZHd+iqCw6 z@kLCrKIldC08xPAGTEm+V1~}f!2{bKt($kNE;p>r?f^|>V`D~yAT$D@GDcw_kwnsZ z6qer99yoeXXak!oroAsGfhxlaJ(=-jtxDAg^{dlgWU7Gx1R~xMIPu2v>KWH%TxeLr zfsLF>KB2UXR_IEGFe=*WT_`&Wh6jBl&pYwCT^7oD9e(|XwX;``dDUsz|8&)?dDndtP{*QTq$MMf(9>q; zEZv6GgCR=jS~cE=i4xO#K!jFz29GwmeJkPs5@;L%zz!DsppmuGasDw(L;ilcSbBH+ z7F$VarQ7Z(aRaj~)VOp7fq4ahc_x5txZVPj2fbZWh=ht&h4O!%Ucc(I@$k`KbOiSQ zWO~ER;R}7TdivZ(ftE}3+#(@@#!w6DIHWF|Q9>q}{9+tGF``Iu-u-RBn(c01jjlpf z_*cdOAf6^@1rALoj{f2CN>5F>Y%00hZuhKBtI8@w#Zv5nQ4k=3WG1xLSzR-~GpnSs zAsEQaTorRvA(!g=U_coFO#qPhbKp=I0DwC179(Qg@(&7;3?6%T@2lAn zYdF(qeOR+O7j>G`2$-aj3RRONb=yT3y{{=NQjG!Gu_&J8 zo=q)BU%5UWYuhYgc(cS3%?PO;1fgQl*ke#6CC%+0ca&W8gn}Jw6*xM=9hQvkZzQm- z&|wuER`i5|cYH<}5$RYc61`*>kQ0F(%riwkf8nn5w!vpXY* zgd#CR1cVQT9oqYB6{6BGzFz_&5%XtHtjzJ%f1pz?nX@5{rFTTb`{yedeu7Pv^CJ<- zm};@hy`S!B+g{IwTq4LagTQgA#%(J#ZeJ=MfMmD>?zynK8e0!G|8;FVa`X-vV><_LxXF8Dlred*y=BKIV!UEQ zdCj%wv_eYG#afc4weH{j;&-%U-~kC$!>tm!LIjdyv7s!Z007KY>bn=lpE-d9a>LO* z|5GqArZeZ>DlE>qn>4atnvOJIu25tvPQo_M43jM#!KPcPreC{#te>gB=@)4PYaeo&1b`!u6e z51zTv3jbz{$GW$2qrsSD zt`dafFYt@ZYPQ%4HhQIY&g!`AtluEeT#+1TzR84%cM87%Es02UAd<-lv*xbRY>xU3 zffKJSm2lu;odh!koG07zEyHLq#uUfI9HMBE70aZk&TTH4_d>As?KKkh|J#NZvAJkX7DjaIt{T&GtO_O1V06>&VMh$7vXQv}}$NND+%!bT(j?anWuDP~V!}2ev zvE!dbQVZ6K%DHWII(hQ`Lwldh_^41>y)qtbedAh_6n(tV6_KGxa~}C^zU3GV#+ag< z%1#(3Xf~PcUj0SNFS2dshMwTg_nD>mRv^v`@8*-8W^47=FKK+=qq1nbK^xfD$OqnW zMME!7$VXaLbA7z!=(bOpApAH3QMkJVN(cLTgYV{BjM2cG@78Ey*+GKy6#29!JsG{6VLpYKOc6CU+v`epO;!w1lgTR;|*SJd*miex1ibam!DWUNKq0a>Z2#amu1rv$$MTP;*Q>#2; zg>UKh&h{Nw$khL9Be!~HNNT+Q$d?3IeC3sM?=ahHztGvfeVW1|!?t8d0A@Ts?qW=4 z=lmvxy6%ubHSCQ&3^cYuDYKOjv&Kd@ow!-Ig?7&FhD$Q()VZc?cK2L)k07U|A>i*P=e5EGA|B$CT4^2vkcazsZ;X%#4vrzyOjn=8ml65|8)q1JYt=J_(XNgI_w zM9f49%co!0DO1we)>70WnrduA5@RfrcG$=y$+jwR{LfQvH9U>URlmMF_~ueZ(RYR^ zV$L>cBYk$7kjhKSX5N47;In7?2X?o;euJ~D_VWNr>FL*q1SJx&j8^hc+v^Ku>fdbC zxLbx=ARh16y@`vSFd;ID3PDsg2-S?amhQ?u~lG`HSLLnHa#8t@01`J%C{VYAObLUzS=q@P?wz0&d{+xNyz*47)vh@L^>7k*_LlP zE(9Zy>P6tanG7Ppe7Rl%6*{H9rA?vM?F$vA8blG#50mt%eO2aN+Jrp(|G+?z3UHw9+_0@}z5(ZX8WB^v(juP(b zWlgf^d-%PsBKZS>ID`0qe0HnYYbOobTrPG#u!p!;=>Gnxf)rn z%v_|&iEN+t1-smRlMy3J1W0CY^<`VT+uzV-Tgr*m0uHs3B0|O;mc{{T(MW&Du=#^$ zbLLAy5E+%q0{|e9OySU5H)J}_WF@Lqy&zHl6GrS9#lhO(scw8yiyoeEd+XEK>{Y8r zu6nsEi6Kd%<;002(Ok`!DQA?Bbhs}F5UZ+YT$k}clNb%l?qJmUt=t+Z#sUHdi&wGF z`n`yEYzZ_!Gof&{a98sqHfPP}A%7w4BuER)xcH+6`+m>Od)rY+ZUY@0t;FoB`%k_o zU--(YOGo?uA2Lc9FxCdXm88$>a+}(o(&lo!6E5t{8JKgsF%f+8Wc~enJK7*>!ph zQNfLY7Dq@mOHyJ(e_zL;P_XSJG7{-@ynD{YxAp=6bOpD_l3ejMcSX$=vTUo@IGau& z=b_EoX^2cx@874ndwqW9pBQIWER9EZFqU|V3)5YY$xVQgsmeEVg$htq!t-!&{~LQ| zU%c!~9F^Y-l83H1c~?LH00FWMKw8YXwb4;p8k_07D9#uUAc}wx-OaMZ!j;}dR{%P1 zB9Ii-5DpljMZzb4X||8IzfpcUvl0RTC{p*mDtAAesTE6tL<5f~yKYT-ik8RXrT4oD{!JZY@U7T!8YLmElmZ z`A0I-=X=i`h=T=yjiZ1701Ok)UjXmvK3#NZzzNqjn zZIYn>%M7)Mff5i34g@tGj|P5}Z#gEyFeOxM3*!t$2DycU5Fl#8@uBLP`Jc&jtf@ds z_?sl^`OoS0o;8x{Ngi2)6J2Dbm2B z`Ie&)VaOxV$nkIGTaJk`(f~v8O^Et9k_E|5D+@I0G1g?KqWXFf4WC>G2Fk}P6i`IB znjK3DB2IKPMkrw@c){z6S&$(vkfQ zit`d(tor$4RHuA2?GGzb>P5X)LsiJrOweA;t{5X`XTu9JBo9JS0bx)FN52g%Qv8WR zS3rRCG=w1$-TrqTmPIb~Q1@hk+GYva*y~djg#K^PBjQ#(XZ#nV<5rWzu3kTL$`j$22TN=H& zpc0n*uIWV4`{lFFhMAocQ8KHV^HwwD@CZ$cUtSe&5~89|WA%c=Z{u3$0eaIBR3SA-ew`91>@Q^#UTAY=NSG*zsd z(eRN;xg8(-8IKPwYHnZ^080iy8VRR(M!vlRM z3aW6^cp3A}-`jQIvocGy=sP_khtkhg`xpPDJMh<{B94KI+Eww^mN)N_DY9v@8)^`^ z%Bbgy){=%v<&rp?G2i%QzH2&>dhXI&00Jhd!g;5+deMg7;MQWj(lJmm?FNxfgucrt zW%ve|6Gw1{k>9E0DX1Ev6JcDdk4n`qAgH<<1_&fY!?I6!suw@0_t=vb`@F+u9QZ~i zjeLxY;EEjic_^?;_lLd_k>+0hFXQ@vS?&vPVI8H{K&BuHQ0f)zJR!ibTi>xW$I1eY z4AP&LrPK$J!v0A3Xs^la&8q`F)Vh7ItE|FHq$~hnlVle`gqS`Vj~xA|%Y9|R^pnVh zaVsGgw%sPFPvc~{E-Q*i)(@+RHk+iByr}Qk6UPLtjT%)xr-5@dC+pP&_SGg!`Rx)* zen>*~f5)S3{+44~UN5g~$mto)R&o)A+FpCUw5&`cvaB>(3BrlMm`KEQ0RRw4W}9=)*1piTyes02hL4D}%KhhCWeAX^xqY?SKL3P7iC}Nw&5YZN zjR%W!iDs1t)*`8?T+XW>1OP&qrNr+zRjjL@S2!J&^kBknfw=HDNigv3tT~ODeNK7R z#lOhP*yF@xV$EZ52M_>qw0bN3OE#t=hjSXF9^;-DOf2>*1S-HJV4<2=;+4ROUEj^O zB>5mC-&`=%{7VFpl~QvA$cUAGNXF#xuGZIcy0V;2S{--_VC>sH4zkVctp86%if>6o z_U0@!FBClRuRy8(T+OE!G7~+mCwJaeQFBefm#UZu87X0fcX^y)wT~nro+|0s>^Hga81XO7DzRl&BXD&v2Q=?i(^0=T8RG8Dnq}CI={t+=T&Mn(`K;&eZ zgHpxMOxS)ySNoQnZcjS`hyE;KCN*~uIasE1sCrI;zDLy9k?fvxZ4HN!2JUAJ^R9&m zIP9*FFdb5pN9M`)iziib?nKc|3BCSh+hgIDI}x)N-9P9GuwE;mVncP!lAm?AZ_nAP z==NS4mqgzeGaChwgW0Q6>ED@bGk+_Kt_SszZgdVFcw-xAQA3@z5QrE?*2~uUlfbX3 z54su)Y|eSxQAD#F>4J=DWb&%Q^+}I^@$>z`mvgovroq2mm!w)mB$O1+D!!&r?<1iT zf5}Qi)fw|{jh{HS{dNUnJF_wV#2{^7)0>awTM8qgyTz_2bl@IFiJbIO;AEa&?pg2~ zEw(#nU4fa_{e8VshzJlhEW2y^%w-!>k-b?lI@Qj;u_@HH<2spQ&Dj`#ybyrosh;^j zzU43yx+`IsZ&_<+;Eg#FWha_uIEaFktu{F>Zk4ESV`tl|joF?tEqT^SqW5QdjYohi z#qFyt&Pz@(kqDkV@_eISW1q%dvohS_)2^7&?Jstb*Ec0F2l)Z`60U+hnHke3HUmOFTiVYmO%UUv5_k`A# zLw~BRpS$#KjU0CpDCPO}A)c<4!($TT0SRM|hWpx{wzw8fDXZzYQ<=tt-8EC~Xx;u= zX-Sz2(6oSZlJka0Xs)(7Jh!J}$Ahw|JS(}01pJ!_l6mO7`i;$Gv!(O~89NUOaOirL zE3K#xH}Cu7_S%}7W-jDa1X3PXA;iI2wvw4huH zYQ8~`AzHoe%8S1yi-YUSp3Q)0vA)AvDF-rF;7<()hZvSl{aP;u>hFc~@A>^DY zApk&6>+3gorZqmy(L9p`%ZD-&oYEeobXZ~o-%2FSbtA6g4YXx(EPmr9m zNTi7(QL4u(buEgDnu2v}!NQ08wNsnfvQy2sxfP^YD9t4rtqoyKn#^Zf&$76lX@%X?1 z=jrH-3sf{aeBjSMNiLaRH*?9el58^U`H+Dcj)xB}x4158%C{^N#V|?;01)nY)#moj z|96#KcjhY0Z7P630)ZzP@=gS`1%S69@&E}QMwDCtJfKnP5R+Jxkh%$^Isoe}LbLo0 zfN4l*8wrMkW%q?Z1(4Lg$Yg|o2muHXPW_vNguI_o?|mu^ z?~Zix&>yS3{)XE?a@=aRIO_lG{g{Jdc)yi#$Rxc=aElcCP2j}t@49QQ z&L|k5rTJ-BNl6*l9i=4z%*`alX0zHrmgP7XP=z4RVN3!|QvsPc6puxL^HgU%7U>Zp zJy7mnk=M>wxu77F5CEX}^;3u%_U*d4)n& z^9l9DS~4T1lJ!NNIJQGkBm@*1fK&;W}{<Gmfs+Sct?(^t%C|^G zhBIlE@H9MeWSL^B{60votHhKFgX1Y=$$f~i^})8oFL``d7j$UXWM{sG6&>vb#FSIQvpIV3 zNmf%ctD>~T)2OM+Eds1-fSFu?l35TiBPk{V5rEJTNM%ffxf*# + /// 游戏对象与软引用 (gameobject with soft refrence)。 + /// 将游戏对象引用保存为软引用，这对于经常替换模型的场景来说比较有用。 + /// + [Serializable] + public class GowSoftRef + { + public readonly string interval = "/"; + + /// + /// 对象 + /// + [HorizontalGroup("SoftRef")] + [HideLabel] + public GameObject targetObejct; + + /// + /// 路径 + /// + [HorizontalGroup("SoftRef")] + [HideLabel] + public string targetPath; + + /// + /// 获取对象 + /// + /// + public GameObject GetObject() + { + if (targetObejct == null) + UpdateGameobjectByPath(); + return targetObejct; + } + + /// + /// 将对象制作成路径 + /// + public void UpdatePathByGameobject() + { + if (targetObejct == null) + { + Debug.LogError("对象引用为空，无法获取软引用"); + return; + } + + if (IsPrefab(targetObejct)) + { + targetPath = "I Dont Know"; // todo 获取预制体路径 + return; + } + + if (targetObejct.transform == null) + { + Debug.LogError("对象引用为空，无法获取软引用"); + return; + } + + targetPath = targetObejct.transform.GetFamilyName().Join(a => a, interval: interval); + } + + /// + /// 将路径制作成对象 + /// + /// + public bool UpdateGameobjectByPath() + { + if (MacroObject.FindFamilyMemberExact(null, targetPath.Split(interval), out var target)) + { + targetObejct = target.gameObject; + return true; + } + + return false; + } + + /// + /// 当前的对象是预制体吗 + /// + public bool IsPrefab(Object target) +#if UNITY_EDITOR + { +#if UNITY_6000_0_OR_NEWER + var type = PrefabUtility.GetPrefabAssetType(target); + return type is PrefabAssetType.Regular or PrefabAssetType.Variant; +#else + return PrefabUtility.GetPrefabType(target) == PrefabType.PrefabInstance; +#endif + } +#else + => false; +#endif + } +} \ No newline at end of file diff --git a/Runtime/UI/AutoCanvasScale.cs b/Runtime/UI/AutoCanvasScale.cs new file mode 100644 index 0000000..0bd6af0 --- /dev/null +++ b/Runtime/UI/AutoCanvasScale.cs @@ -0,0 +1,64 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using UnityEngine; +using UnityEngine.UI; +using XericLibrary.Runtime.CustomEditor; + +namespace Deconstruction.Runtime.UI +{ + /// + /// ȡĻ + /// + public class AutoCanvasScale : MonoBehaviour + { + #region ֶ + + public CanvasScaler canvasScaler; + + [Rename("Ƴߴ")] + public Vector2 StandardSize = new Vector2(1920,1080); + + public Vector2 ScaleMinMax = new Vector2(0.5f, 2); + + #endregion + + #region + + private void OnValidate() + { + FindCanvasScaler(); + GetScreenScale(); + } + + private void Awake() + { + FindCanvasScaler(); + } + + private void LateUpdate() + { + canvasScaler.scaleFactor = GetScreenScale(); + } + + #endregion + + #region + + private void FindCanvasScaler() + { + if (canvasScaler == null) + canvasScaler = transform.GetComponent(); + } + + private float GetScreenScale() + { + Vector2 screenSize = new Vector2(Screen.width, Screen.height); + // Debug.Log(canvasScaler.referenceResolution); + var sf = screenSize / StandardSize; + return Mathf.Clamp(Mathf.Min(sf.x, sf.y), ScaleMinMax.x, ScaleMinMax.y); + } + + #endregion + } +} \ No newline at end of file diff --git a/Runtime/UI/CircleSlider.cs b/Runtime/UI/CircleSlider.cs new file mode 100644 index 0000000..9fff943 --- /dev/null +++ b/Runtime/UI/CircleSlider.cs @@ -0,0 +1,429 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using UnityEngine; +using UnityEngine.EventSystems; +using UnityEngine.UI; + +namespace Deconstruction.Runtime.UI +{ + public class CircleSlider : Selectable, IDragHandler, IEndDragHandler, IBeginDragHandler + { + [SerializeField] private RectTransform m_HandleRect; + + public RectTransform handleRect + { + get { return m_HandleRect; } + set + { + if (SetPropertyUtility.SetClass(ref m_HandleRect, value)) + { + UpdateCachedReferences(); + UpdateVisuals(); + } + } + } + + [SerializeField] private RectTransform m_FillRect; + + public RectTransform fillrect + { + get { return m_FillRect; } + set + { + if (SetPropertyUtility.SetClass(ref m_FillRect, value)) + { + UpdateCachedReferences(); + UpdateVisuals(); + } + } + } + + [SerializeField] private float m_MinValue = 0; + + public float minValue + { + get => m_MinValue; + set + { + if (SetPropertyUtility.SetStruct(ref m_MinValue, value)) + { + Set(m_Value); + UpdateVisuals(); + } + } + } + + [SerializeField] private float m_MaxValue = 1; + + public float maxValue + { + get { return m_MaxValue; } + set + { + if (SetPropertyUtility.SetStruct(ref m_MaxValue, value)) + { + Set(m_Value); + UpdateVisuals(); + } + } + } + + [SerializeField] private float m_Value; + + public float value + { + get + { + if (wholeNumbers) + return Mathf.Round(m_Value); + return m_Value; + } + set { Set(value); } + } + + [SerializeField] private Image.Origin360 m_FillOrigin; + + public Image.Origin360 fillOrigin + { + get { return m_FillOrigin; } + set + { + if (SetPropertyUtility.SetStruct(ref m_FillOrigin, value)) + { + Set(m_Value); + UpdateVisuals(); + } + } + } + + [SerializeField] private float m_Radius; + + public float radius + { + get { return m_Radius; } + set + { + if (SetPropertyUtility.SetStruct(ref m_Radius, value)) + { + UpdateVisuals(); + } + } + } + + [SerializeField] private bool m_ClockWise; + + public bool clockWise + { + get { return m_ClockWise; } + set + { + if (SetPropertyUtility.SetStruct(ref m_ClockWise, value)) + { + UpdateCachedReferences(); + UpdateVisuals(); + } + } + } + + [SerializeField] private bool m_WholeNumbers = false; + + public bool wholeNumbers + { + get { return m_WholeNumbers; } + set + { + if (SetPropertyUtility.SetStruct(ref m_WholeNumbers, value)) + { + Set(m_Value); + UpdateVisuals(); + } + } + } + + public float normalizedValue + { + get + { + if (Mathf.Approximately(m_MinValue, m_MaxValue)) + return 0; + return Mathf.InverseLerp(m_MinValue, m_MaxValue, value); + } + + set { this.value = Mathf.Lerp(m_MinValue, m_MaxValue, value); } + } + + private Action m_OnValueChanged; + private Action m_OnDragEnd; + private Action m_OnTweenComplete; + private Image m_FillImage; + private bool m_DelayedUpdateVisuals = false; + private bool m_dragHandler; + private Camera m_eventCamera; + private Coroutine m_TweenCor; + + + protected override void OnEnable() + { + UpdateCachedReferences(); + Set(m_Value); + } + +#if UNITY_EDITOR + protected override void OnValidate() + { + base.OnValidate(); + if (IsActive()) + { + UpdateCachedReferences(); + Set(m_Value, false); + m_DelayedUpdateVisuals = true; + } + } +#endif + + void Update() + { + if (m_DelayedUpdateVisuals) + { + m_DelayedUpdateVisuals = false; + UpdateVisuals(); + } + } + + void UpdateCachedReferences() + { + if (m_FillRect != null) + { + m_FillImage = m_FillRect.GetComponent(); + m_FillImage.fillMethod = Image.FillMethod.Radial360; + m_FillImage.fillOrigin = (int)m_FillOrigin; + m_FillImage.fillClockwise = m_ClockWise; + } + } + + private bool MayDrag(PointerEventData eventData) + { + return IsActive() && IsInteractable() && eventData.button == PointerEventData.InputButton.Left; + } + + public void OnDrag(PointerEventData eventData) + { + if (!MayDrag(eventData)) + return; + if (m_dragHandler) + { + Vector2 localCursor; + if (!RectTransformUtility.ScreenPointToLocalPointInRectangle(m_FillRect, eventData.position, + eventData.pressEventCamera, out localCursor)) + return; + float angle = CalAngle(localCursor); + normalizedValue = (angle / 360); + } + } + + + public void OnEndDrag(PointerEventData eventData) + { + m_dragHandler = false; + if (m_OnDragEnd != null) + { + m_OnDragEnd(); + } + } + + public void OnBeginDrag(PointerEventData eventData) + { + if (m_HandleRect != null) + { + if (RectTransformUtility.RectangleContainsScreenPoint(m_HandleRect, eventData.position, + eventData.enterEventCamera)) + { + m_dragHandler = true; + } + } + else + { + m_dragHandler = true; + } + } + + + private float CalAngle(Vector2 pos) + { + float angle = 0; + float rad = Mathf.Atan2(pos.y, pos.x) * Mathf.Rad2Deg; + switch (m_FillOrigin) + { + case Image.Origin360.Top: + angle = m_ClockWise ? 90 - rad : rad + 270; + break; + case Image.Origin360.Left: + angle = m_ClockWise ? 180 - rad : rad + 180; + break; + case Image.Origin360.Right: + angle = m_ClockWise ? -rad : rad; + break; + case Image.Origin360.Bottom: + angle = m_ClockWise ? 270 - rad : rad + 90; + break; + } + + if (angle > 360) + { + angle -= 360; + } + + if (angle < 0) + { + angle += 360; + } + + return angle; + } + + private void UpdateVisuals() + { +#if UNITY_EDITOR + if (!Application.isPlaying) + UpdateCachedReferences(); +#endif + if (m_FillImage != null) + { + m_FillImage.fillAmount = normalizedValue; + } + + if (m_HandleRect != null) + { + m_HandleRect.transform.localPosition = CalPos(normalizedValue * 360); + } + } + + private Vector2 CalPos(float angle) + { + Vector2 pos = Vector2.zero; + switch (m_FillOrigin) + { + case Image.Origin360.Left: + angle = m_ClockWise ? 180 - angle : angle + 180; + break; + case Image.Origin360.Top: + angle = m_ClockWise ? 90 - angle : angle + 90; + break; + case Image.Origin360.Right: + angle = m_ClockWise ? -angle : angle; + break; + case Image.Origin360.Bottom: + angle = m_ClockWise ? 270 - angle : angle - 90; + break; + } + + angle = Mathf.Deg2Rad * angle; + pos.y = Mathf.Sin(angle) * m_Radius; + pos.x = Mathf.Cos(angle) * m_Radius; + return pos; + } + + + private void Set(float input, bool sendCallback = true) + { + float newValue = ClampValue(input); + if (m_Value == newValue) + return; + + m_Value = newValue; + UpdateVisuals(); + if (sendCallback) + { + if (m_OnValueChanged != null) + { + m_OnValueChanged.Invoke(newValue); + } + } + } + + float ClampValue(float input) + { + float newValue = Mathf.Clamp(input, m_MinValue, m_MaxValue); + if (wholeNumbers) + newValue = Mathf.Round(newValue); + return newValue; + } + + public void OnValueChange(Action call) + { + m_OnValueChanged = call; + } + + public void OnDragEnd(Action call) + { + m_OnDragEnd = call; + } + + public void TweenValue(float val, float time, Action call = null) + { + m_TweenCor = StartCoroutine(_tweenValue(val, time)); + m_OnTweenComplete = call; + } + + public void StopTween() + { + if (m_TweenCor != null) + { + StopCoroutine(m_TweenCor); + } + } + + IEnumerator _tweenValue(float val, float time) + { + float t = 0; + float oldValue = value; + float interval = val - oldValue; + + while (t < time) + { + t += Time.deltaTime; + value = oldValue + (t / time) * interval; + yield return 0; + } + + if (m_OnTweenComplete != null) + { + m_OnTweenComplete(); + } + + value = val; + } + } + + internal static class SetPropertyUtility + { + public static bool SetColor(ref Color currentValue, Color newValue) + { + if (currentValue.r == newValue.r && currentValue.g == newValue.g && currentValue.b == newValue.b && + currentValue.a == newValue.a) + return false; + + currentValue = newValue; + return true; + } + + public static bool SetStruct(ref T currentValue, T newValue) where T : struct + { + if (EqualityComparer.Default.Equals(currentValue, newValue)) + return false; + + currentValue = newValue; + return true; + } + + public static bool SetClass(ref T currentValue, T newValue) where T : class + { + if ((currentValue == null && newValue == null) || (currentValue != null && currentValue.Equals(newValue))) + return false; + + currentValue = newValue; + return true; + } + } +} \ No newline at end of file diff --git a/Runtime/UI/MacroUI.cs b/Runtime/UI/MacroUI.cs new file mode 100644 index 0000000..b0724df --- /dev/null +++ b/Runtime/UI/MacroUI.cs @@ -0,0 +1,494 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.Linq; +using System.Reflection; + +using TMPro; +using UnityEngine; +using UnityEngine.Events; +using UnityEngine.UI; +using XericLibrary.Runtime.CustomEditor; +using Object = UnityEngine.Object; + +using Sirenix.OdinInspector; +#if UNITY_EDITOR +using Sirenix.Utilities.Editor; +#endif + +namespace XericLibrary.Runtime.MacroLibrary +{ + /// + /// UI相关的扩展 + /// + public static class MacroUI + { + #region toggle 扩展 + + private static FieldInfo togglesFieldInfo = typeof(ToggleGroup).GetField("m_Toggles", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); + + public static List GetToggles(this ToggleGroup toggleGroup) + { + if (toggleGroup == null) + { + throw new ArgumentNullException(nameof(toggleGroup)); + } + + if (togglesFieldInfo == null) + { + throw new InvalidOperationException("Unable to access the 'm_Toggles' field."); + } + + var toggles = togglesFieldInfo.GetValue(toggleGroup) as List; + if (toggles == null) + { + throw new InvalidCastException("The 'm_Toggles' field is not of type List."); + } + + return toggles; + // return (List)togglesFieldInfo.GetValue(toggleGroup); + } + + /// + /// 获取当前单选项组中激活的索引 + /// + /// + /// + [Obsolete("索引依赖单选项自身在大纲中的顺序，在运行时顺序可能与编辑时不一致，请使用ToggleMapping")] + public static int GetActiveToggleIndex(this ToggleGroup toggleGroup) + { + var index = -1; + foreach (var toggle in toggleGroup.GetToggles()) + { + index++; + if (toggle.isOn) + return index; + } + + return -1; + } + + /// + /// 获取当前单选项组的数量 + /// + /// + /// + public static int GetToggleCount(this ToggleGroup toggleGroup) + { + return toggleGroup.GetToggles().Count; + } + + + + /// + /// 在单选项组上注册一个事件，当组中的任意成员变成激活状态时调用（其他的不会发生调用）。 + /// + /// + /// + public static void OnToggleGroupChangeEvent(this ToggleGroup toggleGroup, Action onToggleChange) + { + foreach (var toggle in toggleGroup.GetToggles()) + { + toggle.onValueChanged.AddListener(a => + { + if (!a) return; + onToggleChange?.Invoke(toggle); + }); + } + } + /// + /// 清空单选项组中的所有事件（与注册所有事件对应，但那个事件没法单独注销） + /// + /// + public static void RemoveToggleGroupChangeEvent(this ToggleGroup toggleGroup) + { + foreach (var toggle in toggleGroup.GetToggles()) + { + toggle.onValueChanged.RemoveAllListeners(); + } + } + + #region toggle 索引 + + /// + /// toggle映射集 + /// + /// toggle映射集必须使用unity序列化管理，否则和直接使用toggleGroup没区别，目的是解决toggleGroup在打包后大纲视图的索引可能发生错位的问题。 + /// + /// + [Serializable] + public class ToggleMapping : IEnumerable + { + #region 事件委托 + + /// + /// 在单选项目切换时产生回调，返回选中的单选项目在组中的引用 + /// + public Action OnAnyToggleSwitchOn; + + /// + /// 在单选项目切换时产生回调，返回选中的单选项目在组中的索引 + /// + public Action OnAnyToggleIndexSwitchOn; + + #endregion + + #region 字段属性 + + [LabelText("单选组")] public ToggleGroup ToggleGroup; + + [SerializeField, LabelText("编辑单选项目顺序")] + [ListDrawerSettings(OnTitleBarGUI = "GetAndSortToggle")] + private List toggleList = new List(); + + // 当前选中的项目 + private int nowSelectToggleIndex = 0; + private Toggle nowSelectToggle = null; + + + public Transform TogglesContext => ToggleGroup.transform; + + /// + /// 当前选中的toggle索引 + /// + public int NowSelectToggleIndex => nowSelectToggleIndex; + + /// + /// 当前选中的toggle + /// + public Toggle NowSelectToggle => nowSelectToggle; + + + /// + /// 获取并给列表排序(顺序不一定与拼音有关) + /// + public void GetAndSortToggle() + { +#if UNITY_EDITOR + // 自动获取并排序 + if (SirenixEditorGUI.ToolbarButton(EditorIcons.Refresh)) + { + var newToggleList = MacroSort.FullCharacterOrderSort(ToggleGroup.GetToggles(), a => a.name).ToList(); + if (newToggleList.Count <= 0 || newToggleList == null) + Debug.LogError("如果无法更新获取自动排序toggle，可能是因为toggleGroup被隐藏了，手动将其激活后再获取即可。"); + else + toggleList = newToggleList; + } + // 反转顺序 + if (SirenixEditorGUI.ToolbarButton(EditorIcons.TriangleDown)) + { + toggleList.Reverse(); + } +#else + var newToggleList = MacroSort.FullCharacterOrderSort(ToggleGroup.GetToggles(), a => a.name).ToList(); + if (newToggleList.Count <= 0 || newToggleList == null) + Debug.LogError("如果无法更新获取自动排序toggle，可能是因为toggleGroup被隐藏了，手动将其激活后再获取即可。"); + else + toggleList = newToggleList; +#endif + } + + #endregion + + #region 接口 + + /// + /// 获取索引下的单选项组件 + /// + /// + public Toggle this[int index] => toggleList[index]; + + public int Count => toggleList.Count; + + public IEnumerator GetEnumerator() + { + return toggleList.GetEnumerator(); + } + + IEnumerator IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + + #endregion + + #region 方法 + + /// + /// 初始化 + /// + /// 自动将所有的按键绑定回调事件；如果作为刷新函数调用，请确保已经完全组索引。 + /// 或者可以直接清空旧项目(CleanToggle)，然后逐个添加(AddToggle) + /// + /// + public void Initialize() + { + // 未指定组时，说明压根没用这部分功能，用不着初始化。 + if (ToggleGroup == null) + return; + + // 防呆警告 + if (toggleList.Count <= 0) + { + var toggles = ToggleGroup.GetToggles(); + if (toggles.Count != toggleList.Count) + { + toggleList = toggles; + Debug.LogWarning($"在初始化单选项组时，{ToggleGroup.name}并未预先指定索引顺序，将默认使用大纲顺序。"); + } + } + // 事件初始化 + for (int i = 0; i < toggleList.Count; i++) + { + var toggle = toggleList[i]; + + ToggleAddEvent(toggle); + + if (toggle.isOn) + { + nowSelectToggleIndex = i; + nowSelectToggle = toggle; + } + } + + if (nowSelectToggle == null) + SetToggleOn(0); + } + + /// + /// 添加一个toggle + /// + /// + /// 返回toggle的索引 + public int AddToggle(Toggle t) + { + ToggleAddEvent(t); + + var resultIndex = toggleList.Count; + toggleList.Add(t); + return resultIndex; + } + + /// + /// 移除一个toggle，这不会影响其他toggle的索引，但此处移除的位置会为空。 + /// + /// 注 ：这不会销毁toggle。 + /// + /// + /// + /// 是否成功移除toggle + public bool RemoveToggle(Toggle t) + { + var index = toggleList.IndexOf(t); + if (index < 0) + return false; + + t.onValueChanged.RemoveAllListeners(); + toggleList[index] = null; + return true; + } + + /// + /// 清除toggle + /// + /// 是否同时销毁所有toggle + public void CleanToggle(bool allowDestroy) + { + foreach (var t in toggleList) + { + t.onValueChanged.RemoveAllListeners(); + if (allowDestroy) + Object.Destroy(t); + } + toggleList.Clear(); + } + + + + /// + /// toggle注册的事件，只有当按下时才需要调用此事件。 + /// + /// + private void ToggleAddEvent(Toggle t) + { + t.onValueChanged.AddListener(a => + { + if (a) ToggleRegister(t); + }); + } + + /// + /// toggle注册的事件，只有当按下时才需要调用此事件。 + /// + /// + private void ToggleRegister(Toggle t) + { + nowSelectToggle = t; + nowSelectToggleIndex = GetIndex(t); + OnAnyToggleSwitchOn?.Invoke(t); + OnAnyToggleIndexSwitchOn?.Invoke(nowSelectToggleIndex); + } + + + + /// + /// 获取toggle代表的索引 + /// + /// + /// 如果这个toggle不存在于当前的单选项组中，返回-1 + public int GetIndex(Toggle target) + { + return toggleList.IndexOf(target); + } + + /// + /// 获取toggle代表的索引， 如果toggle不存在于这个映射集中，将返回否 + /// + /// + /// + /// + public bool TryGetIndex(Toggle target, out int index) + { + index = toggleList.IndexOf(target); + return index >= 0; + } + + /// + /// 设置单选项激活 + /// + /// + public void SetToggleOn(Toggle target) + { + target.isOn = true; + } + /// + /// 设置单选项激活 + /// + /// + public void SetToggleOn(int index) + { + if (0 < index && index < toggleList.Count) + { + SetToggleOn(toggleList[index]); + } + } + /// + /// 设置单选项激活 + /// + /// + public void SetToggleOnWithoutNotify(Toggle target) + { + target.SetIsOnWithoutNotify(true); + } + /// + /// 设置单选项激活 + /// + /// + public void SetToggleOnWithoutNotify(int index) + { + if (0 < index && index < toggleList.Count) + { + SetToggleOnWithoutNotify(toggleList[index]); + } + } + + + /// + /// 清除映射结构(不会清除toggle实例) + /// + public void Clear() + { + ToggleGroup.RemoveToggleGroupChangeEvent(); + toggleList.Clear(); + } + + /// + /// 清除映射结构，并销毁所有toggle组件 + /// + public void RemoveAllToggle() + { + for (int i = toggleList.Count - 1; i >= 0; i--) + { + Object.Destroy(toggleList[i]); + } + Clear(); + } + + #endregion + + } + + #endregion + + #endregion + + #region 按钮扩展 + + /// + /// 所有按钮注册一个事件 + /// + /// + /// + public static void RegisterOnClickEvent(this IEnumerable